From f8d6fc1d106a6b3fa2dbd4085b69e56d64cfd941 Mon Sep 17 00:00:00 2001 From: Josh Stone Date: Fri, 3 Apr 2020 13:21:12 -0700 Subject: [PATCH 1/2] Open-code Fuse's Option matches --- src/libcore/iter/adapters/fuse.rs | 77 +++++++++++++++++-------------- 1 file changed, 42 insertions(+), 35 deletions(-) diff --git a/src/libcore/iter/adapters/fuse.rs b/src/libcore/iter/adapters/fuse.rs index a60ca64ec87c8..bdfeb75a868c8 100644 --- a/src/libcore/iter/adapters/fuse.rs +++ b/src/libcore/iter/adapters/fuse.rs @@ -28,6 +28,22 @@ impl Fuse { #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for Fuse where I: Iterator {} +/// Fuse the iterator if the expression is `None`. +macro_rules! fuse { + ($self:ident . iter . $($call:tt)+) => { + match $self.iter { + Some(ref mut iter) => match iter.$($call)+ { + None => { + $self.iter = None; + None + } + item => item, + }, + None => None, + } + }; +} + #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for Fuse where @@ -37,35 +53,36 @@ where #[inline] default fn next(&mut self) -> Option<::Item> { - let next = self.iter.as_mut()?.next(); - if next.is_none() { - self.iter = None; - } - next + fuse!(self.iter.next()) } #[inline] default fn nth(&mut self, n: usize) -> Option { - let nth = self.iter.as_mut()?.nth(n); - if nth.is_none() { - self.iter = None; - } - nth + fuse!(self.iter.nth(n)) } #[inline] default fn last(self) -> Option { - self.iter?.last() + match self.iter { + Some(iter) => iter.last(), + None => None, + } } #[inline] default fn count(self) -> usize { - self.iter.map_or(0, I::count) + match self.iter { + Some(iter) => iter.count(), + None => 0, + } } #[inline] default fn size_hint(&self) -> (usize, Option) { - self.iter.as_ref().map_or((0, Some(0)), I::size_hint) + match self.iter { + Some(ref iter) => iter.size_hint(), + None => (0, Some(0)), + } } #[inline] @@ -98,11 +115,7 @@ where where P: FnMut(&Self::Item) -> bool, { - let found = self.iter.as_mut()?.find(predicate); - if found.is_none() { - self.iter = None; - } - found + fuse!(self.iter.find(predicate)) } } @@ -113,20 +126,12 @@ where { #[inline] default fn next_back(&mut self) -> Option<::Item> { - let next = self.iter.as_mut()?.next_back(); - if next.is_none() { - self.iter = None; - } - next + fuse!(self.iter.next_back()) } #[inline] default fn nth_back(&mut self, n: usize) -> Option<::Item> { - let nth = self.iter.as_mut()?.nth_back(n); - if nth.is_none() { - self.iter = None; - } - nth + fuse!(self.iter.nth_back(n)) } #[inline] @@ -159,11 +164,7 @@ where where P: FnMut(&Self::Item) -> bool, { - let found = self.iter.as_mut()?.rfind(predicate); - if found.is_none() { - self.iter = None; - } - found + fuse!(self.iter.rfind(predicate)) } } @@ -173,11 +174,17 @@ where I: ExactSizeIterator, { default fn len(&self) -> usize { - self.iter.as_ref().map_or(0, I::len) + match self.iter { + Some(ref iter) => iter.len(), + None => 0, + } } default fn is_empty(&self) -> bool { - self.iter.as_ref().map_or(true, I::is_empty) + match self.iter { + Some(ref iter) => iter.is_empty(), + None => true, + } } } From 6fdd4f37b7eb68a4a44d97db70ee6b805255f0e6 Mon Sep 17 00:00:00 2001 From: Josh Stone Date: Fri, 3 Apr 2020 13:30:21 -0700 Subject: [PATCH 2/2] Use a macro to expand the specialized Fuse --- src/libcore/iter/adapters/fuse.rs | 64 +++++++++++-------------------- 1 file changed, 23 insertions(+), 41 deletions(-) diff --git a/src/libcore/iter/adapters/fuse.rs b/src/libcore/iter/adapters/fuse.rs index bdfeb75a868c8..23bc215aa779d 100644 --- a/src/libcore/iter/adapters/fuse.rs +++ b/src/libcore/iter/adapters/fuse.rs @@ -188,34 +188,16 @@ where } } -// NOTE: for `I: FusedIterator`, we assume that the iterator is always `Some` -impl Fuse { - #[inline(always)] - fn as_inner(&self) -> &I { - match self.iter { - Some(ref iter) => iter, +// NOTE: for `I: FusedIterator`, we assume that the iterator is always `Some`. +// Implementing this as a directly-expanded macro helps codegen performance. +macro_rules! unchecked { + ($self:ident) => { + match $self { + Fuse { iter: Some(iter) } => iter, // SAFETY: the specialized iterator never sets `None` - None => unsafe { intrinsics::unreachable() }, + Fuse { iter: None } => unsafe { intrinsics::unreachable() }, } - } - - #[inline(always)] - fn as_inner_mut(&mut self) -> &mut I { - match self.iter { - Some(ref mut iter) => iter, - // SAFETY: the specialized iterator never sets `None` - None => unsafe { intrinsics::unreachable() }, - } - } - - #[inline(always)] - fn into_inner(self) -> I { - match self.iter { - Some(iter) => iter, - // SAFETY: the specialized iterator never sets `None` - None => unsafe { intrinsics::unreachable() }, - } - } + }; } #[stable(feature = "fused", since = "1.26.0")] @@ -225,27 +207,27 @@ where { #[inline] fn next(&mut self) -> Option<::Item> { - self.as_inner_mut().next() + unchecked!(self).next() } #[inline] fn nth(&mut self, n: usize) -> Option { - self.as_inner_mut().nth(n) + unchecked!(self).nth(n) } #[inline] fn last(self) -> Option { - self.into_inner().last() + unchecked!(self).last() } #[inline] fn count(self) -> usize { - self.into_inner().count() + unchecked!(self).count() } #[inline] fn size_hint(&self) -> (usize, Option) { - self.as_inner().size_hint() + unchecked!(self).size_hint() } #[inline] @@ -255,7 +237,7 @@ where Fold: FnMut(Acc, Self::Item) -> R, R: Try, { - self.as_inner_mut().try_fold(init, fold) + unchecked!(self).try_fold(init, fold) } #[inline] @@ -263,7 +245,7 @@ where where Fold: FnMut(Acc, Self::Item) -> Acc, { - self.into_inner().fold(init, fold) + unchecked!(self).fold(init, fold) } #[inline] @@ -271,7 +253,7 @@ where where P: FnMut(&Self::Item) -> bool, { - self.as_inner_mut().find(predicate) + unchecked!(self).find(predicate) } } @@ -282,12 +264,12 @@ where { #[inline] fn next_back(&mut self) -> Option<::Item> { - self.as_inner_mut().next_back() + unchecked!(self).next_back() } #[inline] fn nth_back(&mut self, n: usize) -> Option<::Item> { - self.as_inner_mut().nth_back(n) + unchecked!(self).nth_back(n) } #[inline] @@ -297,7 +279,7 @@ where Fold: FnMut(Acc, Self::Item) -> R, R: Try, { - self.as_inner_mut().try_rfold(init, fold) + unchecked!(self).try_rfold(init, fold) } #[inline] @@ -305,7 +287,7 @@ where where Fold: FnMut(Acc, Self::Item) -> Acc, { - self.into_inner().rfold(init, fold) + unchecked!(self).rfold(init, fold) } #[inline] @@ -313,7 +295,7 @@ where where P: FnMut(&Self::Item) -> bool, { - self.as_inner_mut().rfind(predicate) + unchecked!(self).rfind(predicate) } } @@ -323,11 +305,11 @@ where I: ExactSizeIterator + FusedIterator, { fn len(&self) -> usize { - self.as_inner().len() + unchecked!(self).len() } fn is_empty(&self) -> bool { - self.as_inner().is_empty() + unchecked!(self).is_empty() } }