From b73241aa5b0eab8aebf1600c598180bbd33be31c Mon Sep 17 00:00:00 2001 From: onestacked Date: Fri, 30 Sep 2022 17:16:59 +0200 Subject: [PATCH 1/3] Added more const_closure functionality. --- library/core/src/cmp.rs | 4 +- library/core/src/const_closure.rs | 79 +++++++++---------- .../core/src/iter/adapters/array_chunks.rs | 12 ++- .../core/src/iter/adapters/by_ref_sized.rs | 10 ++- library/core/src/iter/adapters/mod.rs | 6 +- 5 files changed, 62 insertions(+), 49 deletions(-) diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs index f0fa2e1d2c190..5033e744def02 100644 --- a/library/core/src/cmp.rs +++ b/library/core/src/cmp.rs @@ -1267,7 +1267,7 @@ where { f(v1).cmp(&f(v2)) } - min_by(v1, v2, ConstFnMutClosure::new(&mut f, imp)) + min_by(v1, v2, ConstFnMutClosure { data: &mut f, func: imp }) } /// Compares and returns the maximum of two values. @@ -1352,7 +1352,7 @@ where { f(v1).cmp(&f(v2)) } - max_by(v1, v2, ConstFnMutClosure::new(&mut f, imp)) + max_by(v1, v2, ConstFnMutClosure { data: &mut f, func: imp }) } // Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types diff --git a/library/core/src/const_closure.rs b/library/core/src/const_closure.rs index d2e80e8e7e5df..23b3f87e72172 100644 --- a/library/core/src/const_closure.rs +++ b/library/core/src/const_closure.rs @@ -16,48 +16,45 @@ use crate::marker::Destruct; /// assert!(7 == cl(2)); /// assert!(8 == cl(1)); /// ``` -pub(crate) struct ConstFnMutClosure<'a, CapturedData: ?Sized, Function> { - data: &'a mut CapturedData, - func: Function, +pub(crate) struct ConstFnMutClosure { + /// The Data captured by the Closure. + /// Must be either a (mutable) reference or a tuple of (mutable) references. + pub data: CapturedData, + /// The Function of the Closure, must be: Fn(CapturedData, ClosureArgs) -> ClosureReturn + pub func: Function, } -impl<'a, CapturedData: ?Sized, Function> ConstFnMutClosure<'a, CapturedData, Function> { - /// Function for creating a new closure. - /// - /// `data` is the a mutable borrow of data that is captured from the environment. - /// - /// `func` is the function of the closure, it gets the data and a tuple of the arguments closure - /// and return the return value of the closure. - pub(crate) const fn new( - data: &'a mut CapturedData, - func: Function, - ) -> Self - where - Function: ~const Fn(&mut CapturedData, ClosureArguments) -> ClosureReturnValue, - { - Self { data, func } - } -} - -impl<'a, CapturedData: ?Sized, ClosureArguments, Function, ClosureReturnValue> const - FnOnce for ConstFnMutClosure<'a, CapturedData, Function> -where - Function: - ~const Fn(&mut CapturedData, ClosureArguments) -> ClosureReturnValue + ~const Destruct, -{ - type Output = ClosureReturnValue; +macro_rules! impl_fn_mut_tuple { + ($($var:ident)*) => { + #[allow(unused_parens)] + impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const + FnOnce for ConstFnMutClosure<($(&'a mut $var),*), Function> + where + Function: ~const Fn(($(&mut $var),*), ClosureArguments) -> ClosureReturnValue+ ~const Destruct, + { + type Output = ClosureReturnValue; - extern "rust-call" fn call_once(mut self, args: ClosureArguments) -> Self::Output { - self.call_mut(args) - } -} + extern "rust-call" fn call_once(mut self, args: ClosureArguments) -> Self::Output { + self.call_mut(args) + } + } + #[allow(unused_parens)] + impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const + FnMut for ConstFnMutClosure<($(&'a mut $var),*), Function> + where + Function: ~const Fn(($(&mut $var),*), ClosureArguments)-> ClosureReturnValue, + { + extern "rust-call" fn call_mut(&mut self, args: ClosureArguments) -> Self::Output { + #[allow(non_snake_case)] + let ($($var),*) = &mut self.data; + (self.func)(($($var),*), args) + } + } -impl<'a, CapturedData: ?Sized, ClosureArguments, Function, ClosureReturnValue> const - FnMut for ConstFnMutClosure<'a, CapturedData, Function> -where - Function: ~const Fn(&mut CapturedData, ClosureArguments) -> ClosureReturnValue, -{ - extern "rust-call" fn call_mut(&mut self, args: ClosureArguments) -> Self::Output { - (self.func)(self.data, args) - } -} + }; + } +impl_fn_mut_tuple!(A); +impl_fn_mut_tuple!(A B); +impl_fn_mut_tuple!(A B C); +impl_fn_mut_tuple!(A B C D); +impl_fn_mut_tuple!(A B C D E); diff --git a/library/core/src/iter/adapters/array_chunks.rs b/library/core/src/iter/adapters/array_chunks.rs index 489fb13c0dc97..02abce986cb38 100644 --- a/library/core/src/iter/adapters/array_chunks.rs +++ b/library/core/src/iter/adapters/array_chunks.rs @@ -88,7 +88,11 @@ where Self: Sized, F: FnMut(B, Self::Item) -> B, { - self.try_fold(init, ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp)).0 + self.try_fold( + init, + ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, + ) + .0 } } @@ -132,7 +136,11 @@ where Self: Sized, F: FnMut(B, Self::Item) -> B, { - self.try_rfold(init, ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp)).0 + self.try_rfold( + init, + ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, + ) + .0 } } diff --git a/library/core/src/iter/adapters/by_ref_sized.rs b/library/core/src/iter/adapters/by_ref_sized.rs index 1945e402ff50e..f3b8cfdb47b37 100644 --- a/library/core/src/iter/adapters/by_ref_sized.rs +++ b/library/core/src/iter/adapters/by_ref_sized.rs @@ -44,8 +44,12 @@ impl Iterator for ByRefSized<'_, I> { F: FnMut(B, Self::Item) -> B, { // `fold` needs ownership, so this can't forward directly. - I::try_fold(self.0, init, ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp)) - .0 + I::try_fold( + self.0, + init, + ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, + ) + .0 } #[inline] @@ -84,7 +88,7 @@ impl DoubleEndedIterator for ByRefSized<'_, I> { I::try_rfold( self.0, init, - ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp), + ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, ) .0 } diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs index de3a534f81b8a..8f8748feae42c 100644 --- a/library/core/src/iter/adapters/mod.rs +++ b/library/core/src/iter/adapters/mod.rs @@ -209,7 +209,11 @@ where Self: Sized, F: FnMut(B, Self::Item) -> B, { - self.try_fold(init, ConstFnMutClosure::new(&mut fold, NeverShortCircuit::wrap_mut_2_imp)).0 + self.try_fold( + init, + ConstFnMutClosure { data: &mut fold, func: NeverShortCircuit::wrap_mut_2_imp }, + ) + .0 } } From 9a641a533cf3e560bd4133e01dd43250bb784ff5 Mon Sep 17 00:00:00 2001 From: onestacked Date: Fri, 30 Sep 2022 17:16:59 +0200 Subject: [PATCH 2/3] Fixed Documentation for wrap_mut_2_imp --- library/core/src/ops/try_trait.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/core/src/ops/try_trait.rs b/library/core/src/ops/try_trait.rs index 33df9e6c5cd48..84a69046807c4 100644 --- a/library/core/src/ops/try_trait.rs +++ b/library/core/src/ops/try_trait.rs @@ -379,7 +379,7 @@ pub(crate) type ChangeOutputType = <::Residual as Residual>:: pub(crate) struct NeverShortCircuit(pub T); impl NeverShortCircuit { - /// Wrap a binary `FnMut` to return its result wrapped in a `NeverShortCircuit`. + /// Implementation for building `ConstFnMutClosure` for wrapping the output of a ~const FnMut in a `NeverShortCircuit`. #[inline] pub const fn wrap_mut_2_imp T>( f: &mut F, From 10739d475e95b825a3b57a726da5266f7d50c9e7 Mon Sep 17 00:00:00 2001 From: onestacked Date: Fri, 30 Sep 2022 17:41:01 +0200 Subject: [PATCH 3/3] Add back ConstFnMutClosure::new, fix formatting --- library/core/src/cmp.rs | 4 +- library/core/src/const_closure.rs | 63 ++++++++++++------- .../core/src/iter/adapters/array_chunks.rs | 12 +--- .../core/src/iter/adapters/by_ref_sized.rs | 10 +-- library/core/src/iter/adapters/mod.rs | 6 +- 5 files changed, 48 insertions(+), 47 deletions(-) diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs index 5033e744def02..f0fa2e1d2c190 100644 --- a/library/core/src/cmp.rs +++ b/library/core/src/cmp.rs @@ -1267,7 +1267,7 @@ where { f(v1).cmp(&f(v2)) } - min_by(v1, v2, ConstFnMutClosure { data: &mut f, func: imp }) + min_by(v1, v2, ConstFnMutClosure::new(&mut f, imp)) } /// Compares and returns the maximum of two values. @@ -1352,7 +1352,7 @@ where { f(v1).cmp(&f(v2)) } - max_by(v1, v2, ConstFnMutClosure { data: &mut f, func: imp }) + max_by(v1, v2, ConstFnMutClosure::new(&mut f, imp)) } // Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types diff --git a/library/core/src/const_closure.rs b/library/core/src/const_closure.rs index 23b3f87e72172..9e9c02093be20 100644 --- a/library/core/src/const_closure.rs +++ b/library/core/src/const_closure.rs @@ -23,36 +23,53 @@ pub(crate) struct ConstFnMutClosure { /// The Function of the Closure, must be: Fn(CapturedData, ClosureArgs) -> ClosureReturn pub func: Function, } +impl<'a, CapturedData: ?Sized, Function> ConstFnMutClosure<&'a mut CapturedData, Function> { + /// Function for creating a new closure. + /// + /// `data` is the a mutable borrow of data that is captured from the environment. + /// If you want Data to be a tuple of mutable Borrows, the struct must be constructed manually. + /// + /// `func` is the function of the closure, it gets the data and a tuple of the arguments closure + /// and return the return value of the closure. + pub(crate) const fn new( + data: &'a mut CapturedData, + func: Function, + ) -> Self + where + Function: ~const Fn(&mut CapturedData, ClosureArguments) -> ClosureReturnValue, + { + Self { data, func } + } +} macro_rules! impl_fn_mut_tuple { ($($var:ident)*) => { - #[allow(unused_parens)] - impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const - FnOnce for ConstFnMutClosure<($(&'a mut $var),*), Function> - where - Function: ~const Fn(($(&mut $var),*), ClosureArguments) -> ClosureReturnValue+ ~const Destruct, - { - type Output = ClosureReturnValue; + #[allow(unused_parens)] + impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const + FnOnce for ConstFnMutClosure<($(&'a mut $var),*), Function> + where + Function: ~const Fn(($(&mut $var),*), ClosureArguments) -> ClosureReturnValue+ ~const Destruct, + { + type Output = ClosureReturnValue; - extern "rust-call" fn call_once(mut self, args: ClosureArguments) -> Self::Output { - self.call_mut(args) + extern "rust-call" fn call_once(mut self, args: ClosureArguments) -> Self::Output { + self.call_mut(args) + } } - } - #[allow(unused_parens)] - impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const - FnMut for ConstFnMutClosure<($(&'a mut $var),*), Function> - where - Function: ~const Fn(($(&mut $var),*), ClosureArguments)-> ClosureReturnValue, - { - extern "rust-call" fn call_mut(&mut self, args: ClosureArguments) -> Self::Output { - #[allow(non_snake_case)] - let ($($var),*) = &mut self.data; - (self.func)(($($var),*), args) + #[allow(unused_parens)] + impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const + FnMut for ConstFnMutClosure<($(&'a mut $var),*), Function> + where + Function: ~const Fn(($(&mut $var),*), ClosureArguments)-> ClosureReturnValue, + { + extern "rust-call" fn call_mut(&mut self, args: ClosureArguments) -> Self::Output { + #[allow(non_snake_case)] + let ($($var),*) = &mut self.data; + (self.func)(($($var),*), args) + } } - } - }; - } +} impl_fn_mut_tuple!(A); impl_fn_mut_tuple!(A B); impl_fn_mut_tuple!(A B C); diff --git a/library/core/src/iter/adapters/array_chunks.rs b/library/core/src/iter/adapters/array_chunks.rs index 02abce986cb38..489fb13c0dc97 100644 --- a/library/core/src/iter/adapters/array_chunks.rs +++ b/library/core/src/iter/adapters/array_chunks.rs @@ -88,11 +88,7 @@ where Self: Sized, F: FnMut(B, Self::Item) -> B, { - self.try_fold( - init, - ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, - ) - .0 + self.try_fold(init, ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp)).0 } } @@ -136,11 +132,7 @@ where Self: Sized, F: FnMut(B, Self::Item) -> B, { - self.try_rfold( - init, - ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, - ) - .0 + self.try_rfold(init, ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp)).0 } } diff --git a/library/core/src/iter/adapters/by_ref_sized.rs b/library/core/src/iter/adapters/by_ref_sized.rs index f3b8cfdb47b37..1945e402ff50e 100644 --- a/library/core/src/iter/adapters/by_ref_sized.rs +++ b/library/core/src/iter/adapters/by_ref_sized.rs @@ -44,12 +44,8 @@ impl Iterator for ByRefSized<'_, I> { F: FnMut(B, Self::Item) -> B, { // `fold` needs ownership, so this can't forward directly. - I::try_fold( - self.0, - init, - ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, - ) - .0 + I::try_fold(self.0, init, ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp)) + .0 } #[inline] @@ -88,7 +84,7 @@ impl DoubleEndedIterator for ByRefSized<'_, I> { I::try_rfold( self.0, init, - ConstFnMutClosure { data: &mut f, func: NeverShortCircuit::wrap_mut_2_imp }, + ConstFnMutClosure::new(&mut f, NeverShortCircuit::wrap_mut_2_imp), ) .0 } diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs index 8f8748feae42c..de3a534f81b8a 100644 --- a/library/core/src/iter/adapters/mod.rs +++ b/library/core/src/iter/adapters/mod.rs @@ -209,11 +209,7 @@ where Self: Sized, F: FnMut(B, Self::Item) -> B, { - self.try_fold( - init, - ConstFnMutClosure { data: &mut fold, func: NeverShortCircuit::wrap_mut_2_imp }, - ) - .0 + self.try_fold(init, ConstFnMutClosure::new(&mut fold, NeverShortCircuit::wrap_mut_2_imp)).0 } }