1111/// This code:
1212///
1313/// ```rust
14- /// use crate::utils::list_node;
14+ /// use leetcode_trees_rs::utils::list_node;
15+ ///
1516/// let node = list_node!(1, 2, 3, 4);
1617/// ```
1718///
1819/// Is the equivalent of the following:
1920///
2021/// ```rust
21- /// use crate::utils::ListNode;
22+ /// use std::boxed::Box;
23+ /// use leetcode_trees_rs::utils::ListNode;
24+ ///
2225/// let node = ListNode {
2326/// val: 1,
24- /// next: Some(Box(ListNode {
27+ /// next: Some(Box::new (ListNode {
2528/// val: 2,
26- /// next: Some(Box(ListNode {
29+ /// next: Some(Box::new (ListNode {
2730/// val: 3,
28- /// next: ListNode::new(4),
31+ /// next: Some(Box::new( ListNode::new(4)) ),
2932/// }))
3033/// }))
31- /// }
34+ /// };
3235/// ```
3336#[ macro_export]
3437macro_rules! list_node {
@@ -98,87 +101,76 @@ macro_rules! tree {
98101///
99102/// ## Example usage
100103/// ```rust
101- /// use crate ::utils::symmetric_tree;
102- /// symmetric_tree!(1, 2, 3, 4)
104+ /// use leetcode_trees_rs ::utils::symmetric_tree;
105+ /// symmetric_tree!(1, 2, 3, 4);
103106/// ```
104107/// The symmetric_tree! macro invocation is desugared to this:
105108/// ```rust
106- /// use std::rc::Rc;
107- /// use std::cell::RefCell;
109+ /// use std::{rc::Rc, cell::RefCell, boxed::Box};
108110///
109- /// use crate ::utils::TreeNode;
111+ /// use leetcode_trees_rs ::utils::TreeNode;
110112///
111113/// TreeNode {
112114/// val: 1,
113- /// left: Some(Box ::new(TreeNode{
115+ /// left: Some(Rc ::new(RefCell::new( TreeNode{
114116/// val: 2,
115- /// left: Some(Box ::new(TreeNode{
117+ /// left: Some(Rc ::new(RefCell::new( TreeNode{
116118/// val: 3,
117- /// left: Some(Box ::new(TreeNode{
119+ /// left: Some(Rc ::new(RefCell::new( TreeNode{
118120/// val: 4,
119121/// left: None,
120122/// right: None,
121- /// }))
122- /// right: Some(Box ::new(TreeNode{
123+ /// }))),
124+ /// right: Some(Rc ::new(RefCell::new( TreeNode{
123125/// val: 4,
124126/// left: None,
125127/// right: None,
126- /// }))
127- /// }))
128- /// right: Some(Box ::new(TreeNode{
128+ /// }))),
129+ /// }))),
130+ /// right: Some(Rc ::new(RefCell::new( TreeNode{
129131/// val: 3,
130- /// left: Some(Box ::new(TreeNode{
132+ /// left: Some(Rc ::new(RefCell::new( TreeNode{
131133/// val: 4,
132134/// left: None,
133135/// right: None,
134- /// }))
135- /// right: Some(Box ::new(TreeNode{
136+ /// }))),
137+ /// right: Some(Rc ::new(RefCell::new( TreeNode{
136138/// val: 4,
137139/// left: None,
138140/// right: None,
139- /// }))
140- /// }))
141- /// }))
142- /// right: Some(Box ::new(TreeNode{
141+ /// }))),
142+ /// }))),
143+ /// }))),
144+ /// right: Some(Rc ::new(RefCell::new( TreeNode{
143145/// val: 2,
144- /// left: Some(Box ::new(TreeNode{
146+ /// left: Some(Rc ::new(RefCell::new( TreeNode{
145147/// val: 3,
146- /// left: Some(Box ::new(TreeNode{
148+ /// left: Some(Rc ::new(RefCell::new( TreeNode{
147149/// val: 4,
148150/// left: None,
149151/// right: None,
150- /// }))
151- /// right: Some(Box ::new(TreeNode{
152+ /// }))),
153+ /// right: Some(Rc ::new(RefCell::new( TreeNode{
152154/// val: 4,
153155/// left: None,
154156/// right: None,
155- /// }))
156- /// }))
157- /// right: Some(Box ::new(TreeNode{
157+ /// }))),
158+ /// }))),
159+ /// right: Some(Rc ::new(RefCell::new( TreeNode{
158160/// val: 3,
159- /// left: Some(Box ::new(TreeNode{
161+ /// left: Some(Rc ::new(RefCell::new( TreeNode{
160162/// val: 4,
161163/// left: None,
162164/// right: None,
163- /// }))
164- /// right: Some(Box ::new(TreeNode{
165+ /// }))),
166+ /// right: Some(Rc ::new(RefCell::new( TreeNode{
165167/// val: 4,
166168/// left: None,
167169/// right: None,
168- /// }))
169- /// }))
170- /// }))
171- /// }
172- /// ```
173- /// I bet you don't want to write that every time.
174- /// You can have greater control with this too:
175- /// ```rust
176- /// use crate::utils::{symmetric_tree, TreeNode};
177- /// TreeNode {
178- /// val: 1,
179- /// left: None,
180- /// right: Some(Box::new(symmetric_tree!(2, 3, 4)))
181- /// }
170+ /// }))),
171+ /// }))),
172+ /// }))),
173+ /// };
182174/// ```
183175/// Now you have a tree that branches all the way through the right side without having anything on
184176/// the left.
@@ -220,7 +212,7 @@ macro_rules! symmetric_tree {
220212/// This code:
221213///
222214/// ```rust
223- /// use crate ::utils::left_tree;
215+ /// use leetcode_trees_rs ::utils::left_tree;
224216///
225217/// let left_only_tree = left_tree!(1, 2, 3);
226218/// ```
@@ -229,7 +221,7 @@ macro_rules! symmetric_tree {
229221///
230222/// ```rust
231223/// use std::{rc::Rc, cell::RefCell};
232- /// use crate ::utils::TreeNode;
224+ /// use leetcode_trees_rs ::utils::TreeNode;
233225///
234226/// let left_only_tree = TreeNode {
235227/// val: 1,
@@ -239,9 +231,9 @@ macro_rules! symmetric_tree {
239231/// val: 3,
240232/// left: None,
241233/// right: None,
242- /// })))
234+ /// }))),
243235/// right: None,
244- /// })))
236+ /// }))),
245237/// right: None,
246238/// };
247239/// ```
@@ -250,9 +242,9 @@ macro_rules! left_tree {
250242 ( $val: expr) => {
251243 $crate:: utils:: TreeNode :: new( $val)
252244 } ;
253- ( $val: expr, $left: tt) => { {
245+ ( $val: expr, $( $ left: tt) * ) => { {
254246 let mut node = $crate:: utils:: TreeNode :: new( $val) ;
255- node. left = Some ( std:: rc:: Rc :: new( std:: cell:: RefCell :: new( left_tree!( $left) ) ) ) ;
247+ node. left = Some ( std:: rc:: Rc :: new( std:: cell:: RefCell :: new( left_tree!( $( $ left) * ) ) ) ) ;
256248 node
257249 } } ;
258250}
@@ -276,7 +268,7 @@ macro_rules! left_tree {
276268/// This code:
277269///
278270/// ```rust
279- /// use crate ::utils::right_tree;
271+ /// use leetcode_trees_rs ::utils::right_tree;
280272///
281273/// let right_only_tree = right_tree!(1, 2, 3);
282274/// ```
@@ -285,7 +277,7 @@ macro_rules! left_tree {
285277///
286278/// ```rust
287279/// use std::{rc::Rc, cell::RefCell};
288- /// use crate ::utils::TreeNode;
280+ /// use leetcode_trees_rs ::utils::TreeNode;
289281///
290282/// let right_only_tree = TreeNode {
291283/// val: 1,
@@ -306,10 +298,10 @@ macro_rules! right_tree {
306298 ( $val: expr) => {
307299 $crate:: utils:: TreeNode :: new( $val)
308300 } ;
309- ( $val: expr, $right: tt) => { {
301+ ( $val: expr, $( $ right: tt) * ) => { {
310302 let mut node = $crate:: utils:: TreeNode :: new( $val) ;
311303 node. right = Some ( std:: rc:: Rc :: new( std:: cell:: RefCell :: new( right_tree!(
312- $right
304+ $( $ right) *
313305 ) ) ) ) ;
314306 node
315307 } } ;
0 commit comments