feat: iter::map on Fn instead of FnOnce

corelib/src/iter/adapters/map.cairo

@@ -24,16 +24,14 @@ pub(crate) impl MapImpl<I, F> of MapTrait<I, F> {
 
 impl MapIterator<
     I,
-    B,
     F,
     impl TIter: Iterator<I>,
-    +core::ops::FnOnce<F, (TIter::Item,)>[Output: B],
+    impl func: core::ops::Fn<F, (TIter::Item,)>,
     +Destruct<I>,
     +Destruct<F>,
-    +Copy<F>,
 > of Iterator<Map<I, F>> {
-    type Item = B;
-    fn next(ref self: Map<I, F>) -> Option<B> {
-        self.iter.next().map(self.f)
+    type Item = func::Output;
+    fn next(ref self: Map<I, F>) -> Option<func::Output> {
+        self.iter.next().map(@self.f)
     }
 }

corelib/src/ops/function.cairo

@@ -23,6 +23,15 @@ impl FnOnceImpl<T, Args, +Destruct<T>, +Fn<T, Args>> of FnOnce<T, Args> {
     }
 }
 
+/// An implementation of `FnOnce` when `Fn` is implemented and the receiver is by-reference.
+/// Makes sure we can always pass an `Fn` to a function that expects an `FnOnce`.
+impl FnOnceSnapImpl<T, Args, +Destruct<T>, +Fn<T, Args>> of FnOnce<@T, Args> {
+    type Output = Fn::<T, Args>::Output;
+    fn call(self: @T, args: Args) -> Self::Output {
+        Fn::call(self, args)
+    }
+}
+
 /// The version of the call operator that takes a by-snapshot receiver.
 ///
 /// Instances of `Fn` can be called multiple times.