Make it possible to have const impls for Iterator

Author: fee1-dead

library/core/src/cmp.rs

@@ -1192,7 +1192,13 @@ pub fn min<T: Ord>(v1: T, v2: T) -> T {
 #[inline]
 #[must_use]
 #[stable(feature = "cmp_min_max_by", since = "1.53.0")]
-pub fn min_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "none")]
+pub const fn min_by<T, F>(v1: T, v2: T, compare: F) -> T
+where
+    F: ~const FnOnce(&T, &T) -> Ordering,
+    F: ~const Drop,
+    T: ~const Drop,
+{
     match compare(&v1, &v2) {
         Ordering::Less | Ordering::Equal => v1,
         Ordering::Greater => v2,
@@ -1255,7 +1261,13 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
 #[inline]
 #[must_use]
 #[stable(feature = "cmp_min_max_by", since = "1.53.0")]
-pub fn max_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "none")]
+pub const fn max_by<T, F>(v1: T, v2: T, compare: F) -> T
+where
+    F: ~const FnOnce(&T, &T) -> Ordering,
+    F: ~const Drop,
+    T: ~const Drop,
+{
     match compare(&v1, &v2) {
         Ordering::Less | Ordering::Equal => v2,
         Ordering::Greater => v1,

library/core/src/internal_macros.rs

@@ -187,3 +187,52 @@ macro_rules! impl_fn_for_zst {
         )+
     }
 }
+
+macro_rules! impl_const_closure {
+    (
+        impl$(<$( $tt : tt ),*>)?
+        const FnOnce for $Name: path $(where $($WhereTy:ty : $(~ $const:ident)? $Trait:path),+ $(,)?)? =
+            $(#[$meta:meta])*
+            |$mutorself:ident $($self:ident)?, $( $arg: tt: $ArgTy: ty ),*| $(-> $ReturnTy: ty)?
+            $body: block;
+    ) => {
+        #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+        impl $( < $( $tt ),* > )? const FnOnce<($( $ArgTy, )*)> for $Name
+            $(where $($WhereTy: $(~$const)? $Trait),+)?
+        {
+            #[allow(unused_parens)]
+            type Output = ( $( $ReturnTy )? );
+
+            #[allow(unused_mut)]
+            $(#[$meta])*
+            extern "rust-call" fn call_once($mutorself $($self)?, ($( $arg, )*): ($( $ArgTy, )*)) -> Self::Output {
+                $body
+            }
+        }
+    };
+    (
+        impl$(< $( $tt: tt ),* >)?
+        const FnMut for $Name: path $(where $($WhereTy:ty : $(~ $const:ident)? $Trait:path),+ $(,)?)? =
+            $(#[$meta:meta])*
+            |&mut $self:ident, $( $arg: tt: $ArgTy: ty ),*| $(-> $ReturnTy: ty)?
+            $body: block;
+    ) => {
+        impl_const_closure! {
+            impl$(< $( $tt ),* >)?
+            const FnOnce for $Name $(where $($WhereTy: $(~$const)? $Trait),+)? =
+                $(#[$meta])*
+                |mut $self, $( $arg: $ArgTy),*| $(-> $ReturnTy)?
+                $body;
+        }
+        #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+        impl $( < $( $tt ),* > )? const FnMut<($( $ArgTy, )*)> for $Name
+            $(where $($WhereTy: $(~$const)? $Trait),+)?
+        {
+            $(#[$meta])*
+            #[allow(unused_parens)]
+            extern "rust-call" fn call_mut(&mut $self, ($( $arg, )*): ($( $ArgTy, )*)) -> ( $($ReturnTy)? ) {
+                $body
+            }
+        }
+    }
+}

library/core/src/iter/adapters/chain.rs

@@ -32,7 +32,7 @@ pub struct Chain<A, B> {
     b: Option<B>,
 }
 impl<A, B> Chain<A, B> {
-    pub(in super::super) fn new(a: A, b: B) -> Chain<A, B> {
+    pub(in super::super) const fn new(a: A, b: B) -> Chain<A, B> {
         Chain { a: Some(a), b: Some(b) }
     }
 }

library/core/src/iter/adapters/cloned.rs

@@ -19,7 +19,7 @@ pub struct Cloned<I> {
 }
 
 impl<I> Cloned<I> {
-    pub(in crate::iter) fn new(it: I) -> Cloned<I> {
+    pub(in crate::iter) const fn new(it: I) -> Cloned<I> {
         Cloned { it }
     }
 }

library/core/src/iter/adapters/copied.rs

@@ -19,7 +19,7 @@ pub struct Copied<I> {
 }
 
 impl<I> Copied<I> {
-    pub(in crate::iter) fn new(it: I) -> Copied<I> {
+    pub(in crate::iter) const fn new(it: I) -> Copied<I> {
         Copied { it }
     }
 }

library/core/src/iter/adapters/cycle.rs

@@ -15,8 +15,12 @@ pub struct Cycle<I> {
     iter: I,
 }
 
-impl<I: Clone> Cycle<I> {
-    pub(in crate::iter) fn new(iter: I) -> Cycle<I> {
+impl<I> Cycle<I> {
+    #[rustc_const_unstable(feature = "iter_internals", issue = "none")]
+    pub(in crate::iter) const fn new(iter: I) -> Cycle<I>
+    where
+        I: ~const Clone,
+    {
         Cycle { orig: iter.clone(), iter }
     }
 }

library/core/src/iter/adapters/enumerate.rs

@@ -19,7 +19,7 @@ pub struct Enumerate<I> {
     count: usize,
 }
 impl<I> Enumerate<I> {
-    pub(in crate::iter) fn new(iter: I) -> Enumerate<I> {
+    pub(in crate::iter) const fn new(iter: I) -> Enumerate<I> {
         Enumerate { iter, count: 0 }
     }
 }

library/core/src/iter/adapters/filter.rs

@@ -18,7 +18,7 @@ pub struct Filter<I, P> {
     predicate: P,
 }
 impl<I, P> Filter<I, P> {
-    pub(in crate::iter) fn new(iter: I, predicate: P) -> Filter<I, P> {
+    pub(in crate::iter) const fn new(iter: I, predicate: P) -> Filter<I, P> {
         Filter { iter, predicate }
     }
 }

library/core/src/iter/adapters/filter_map.rs

@@ -17,7 +17,7 @@ pub struct FilterMap<I, F> {
     f: F,
 }
 impl<I, F> FilterMap<I, F> {
-    pub(in crate::iter) fn new(iter: I, f: F) -> FilterMap<I, F> {
+    pub(in crate::iter) const fn new(iter: I, f: F) -> FilterMap<I, F> {
         FilterMap { iter, f }
     }
 }

library/core/src/iter/adapters/flatten.rs

@@ -14,8 +14,9 @@ pub struct FlatMap<I, U: IntoIterator, F> {
 }
 
 impl<I: Iterator, U: IntoIterator, F: FnMut(I::Item) -> U> FlatMap<I, U, F> {
-    pub(in crate::iter) fn new(iter: I, f: F) -> FlatMap<I, U, F> {
-        FlatMap { inner: FlattenCompat::new(iter.map(f)) }
+    #[rustc_const_unstable(feature = "iter_internals", issue = "none")]
+    pub(in crate::iter) const fn new(iter: I, f: F) -> FlatMap<I, U, F> {
+        FlatMap { inner: FlattenCompat::new(Map::new(iter, f)) }
     }
 }
 
@@ -152,7 +153,8 @@ pub struct Flatten<I: Iterator<Item: IntoIterator>> {
 }
 
 impl<I: Iterator<Item: IntoIterator>> Flatten<I> {
-    pub(in super::super) fn new(iter: I) -> Flatten<I> {
+    #[rustc_const_unstable(feature = "iter_internals", issue = "none")]
+    pub(in super::super) const fn new(iter: I) -> Flatten<I> {
         Flatten { inner: FlattenCompat::new(iter) }
     }
 }
@@ -270,13 +272,10 @@ struct FlattenCompat<I, U> {
     frontiter: Option<U>,
     backiter: Option<U>,
 }
-impl<I, U> FlattenCompat<I, U>
-where
-    I: Iterator,
-{
+impl<I, U> FlattenCompat<I, U> {
     /// Adapts an iterator by flattening it, for use in `flatten()` and `flat_map()`.
-    fn new(iter: I) -> FlattenCompat<I, U> {
-        FlattenCompat { iter: iter.fuse(), frontiter: None, backiter: None }
+    const fn new(iter: I) -> FlattenCompat<I, U> {
+        FlattenCompat { iter: super::Fuse::new(iter), frontiter: None, backiter: None }
     }
 }