@@ -215,7 +215,9 @@ pub struct IterMut<'a, T: 'a>(VecDeque<NodeIterMut<'a, T>>);
215
215
impl <T > Tree <T > {
216
216
pub fn iter_mut (& mut self ) -> IterMut <T > {
217
217
let mut deque = VecDeque :: new ();
218
- self . root. as_mut (). map (| root | deque . push_front (root . iter_mut ()));
218
+ if let Some (root ) = self . root. as_mut () {
219
+ deque . push_front (root . iter_mut ());
220
+ }
219
221
IterMut (deque )
220
222
}
221
223
}
@@ -224,53 +226,46 @@ impl<T> Node<T> {
224
226
pub fn iter_mut (& mut self ) -> NodeIterMut <T > {
225
227
NodeIterMut {
226
228
elem : Some (& mut self . elem),
227
- left : self . left. as_mut () . map ( | node | & mut * * node ),
228
- right : self . right. as_mut () . map ( | node | & mut * * node ),
229
+ left : self . left. as_deref_mut ( ),
230
+ right : self . right. as_deref_mut ( ),
229
231
}
230
232
}
231
233
}
232
234
233
-
234
235
impl <'a , T > Iterator for NodeIterMut <'a , T > {
235
236
type Item = State <'a , T >;
236
237
237
238
fn next (& mut self ) -> Option <Self :: Item > {
238
- match self . left. take () {
239
- Some (node ) => Some (State :: Node (node )),
240
- None => match self . elem. take () {
241
- Some (elem ) => Some (State :: Elem (elem )),
242
- None => match self . right. take () {
243
- Some (node ) => Some (State :: Node (node )),
244
- None => None ,
245
- }
246
- }
247
- }
239
+ self . left. take (). map (State :: Node ). or_else (|| {
240
+ self . elem
241
+ . take ()
242
+ . map (State :: Elem )
243
+ . or_else (|| self . right. take (). map (State :: Node ))
244
+ })
248
245
}
249
246
}
250
247
251
248
impl <'a , T > DoubleEndedIterator for NodeIterMut <'a , T > {
252
249
fn next_back (& mut self ) -> Option <Self :: Item > {
253
- match self . right. take () {
254
- Some (node ) => Some (State :: Node (node )),
255
- None => match self . elem. take () {
256
- Some (elem ) => Some (State :: Elem (elem )),
257
- None => match self . left. take () {
258
- Some (node ) => Some (State :: Node (node )),
259
- None => None ,
260
- }
261
- }
262
- }
250
+ self . right. take (). map (State :: Node ). or_else (|| {
251
+ self . elem
252
+ . take ()
253
+ . map (State :: Elem )
254
+ . or_else (|| self . left. take (). map (State :: Node ))
255
+ })
263
256
}
264
257
}
265
258
266
259
impl <'a , T > Iterator for IterMut <'a , T > {
267
260
type Item = & 'a mut T ;
268
261
fn next (& mut self ) -> Option <Self :: Item > {
269
262
loop {
270
- match self . 0. front_mut (). and_then (| node_it | node_it . next () ) {
263
+ match self . 0. front_mut (). and_then (Iterator :: next ) {
271
264
Some (State :: Elem (elem )) => return Some (elem ),
272
265
Some (State :: Node (node )) => self . 0. push_front (node . iter_mut ()),
273
- None => if let None = self . 0. pop_front () { return None },
266
+ None => {
267
+ self . 0. pop_front ()? ;
268
+ }
274
269
}
275
270
}
276
271
}
@@ -279,10 +274,12 @@ impl<'a, T> Iterator for IterMut<'a, T> {
279
274
impl <'a , T > DoubleEndedIterator for IterMut <'a , T > {
280
275
fn next_back (& mut self ) -> Option <Self :: Item > {
281
276
loop {
282
- match self . 0. back_mut (). and_then (| node_it | node_it . next_back () ) {
277
+ match self . 0. back_mut (). and_then (DoubleEndedIterator :: next_back ) {
283
278
Some (State :: Elem (elem )) => return Some (elem ),
284
279
Some (State :: Node (node )) => self . 0. push_back (node . iter_mut ()),
285
- None => if let None = self . 0. pop_back () { return None },
280
+ None => {
281
+ self . 0. pop_back ()? ;
282
+ }
286
283
}
287
284
}
288
285
}
0 commit comments