Add Fn impl to Arc

library/alloc/src/sync.rs

@@ -1663,6 +1663,29 @@ impl Arc<dyn Any + Send + Sync> {
     }
 }
 
+#[stable(feature = "arc_fn_impls", since = "1.57.0")]
+impl<Args, F: Fn<Args> + ?Sized> FnOnce<Args> for Arc<F> {
+    type Output = <F as FnOnce<Args>>::Output;
+
+    extern "rust-call" fn call_once(self, args: Args) -> Self::Output {
+        <F as Fn<Args>>::call(&self, args)
+    }
+}
+
+#[stable(feature = "arc_fn_impls", since = "1.57.0")]
+impl<Args, F: Fn<Args> + ?Sized> FnMut<Args> for Arc<F> {
+    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output {
+        <F as Fn<Args>>::call(self, args)
+    }
+}
+
+#[stable(feature = "arc_fn_impls", since = "1.57.0")]
+impl<Args, F: Fn<Args> + ?Sized> Fn<Args> for Arc<F> {
+    extern "rust-call" fn call(&self, args: Args) -> Self::Output {
+        <F as Fn<Args>>::call(self, args)
+    }
+}
+
 impl<T> Weak<T> {
     /// Constructs a new `Weak<T>`, without allocating any memory.
     /// Calling [`upgrade`] on the return value always gives [`None`].

library/alloc/src/sync/tests.rs

@@ -618,3 +618,40 @@ fn test_arc_cyclic_two_refs() {
     assert_eq!(Arc::strong_count(&two_refs), 3);
     assert_eq!(Arc::weak_count(&two_refs), 2);
 }
+
+#[test]
+fn test_arc_fn() {
+    let f = || String::from("hello");
+    let f: Arc<dyn Fn() -> String> = Arc::new(f);
+
+    assert_eq!(quox(&f), "hello");
+}
+
+fn quox<F>(f: &F) -> String
+where
+    F: Fn() -> String,
+{
+    f()
+}
+
+#[test]
+fn test_arc_fn2() {
+    fn apply_fn_once<T>(v: T, f: impl FnOnce(T)) {
+        f(v)
+    }
+    fn apply_fn_mut<T>(v: T, mut f: impl FnMut(T)) {
+        f(v)
+    }
+    fn apply_fn<T>(v: T, f: impl Fn(T)) {
+        f(v)
+    }
+
+    let x = Mutex::new(0);
+    let f = Arc::new(|v: i32| *x.lock().unwrap() += v);
+
+    apply_fn_once(1, f.clone());
+    apply_fn_mut(2, f.clone());
+    apply_fn(4, f.clone());
+
+    assert_eq!(*x.lock().unwrap(), 7);
+}