Introduce MakeMut for efficient Arc handling

Author: Ralith

druid/src/lens.rs

@@ -16,6 +16,7 @@
 
 use std::marker::PhantomData;
 use std::ops;
+use std::sync::Arc;
 
 pub use druid_derive::Lens;
 
@@ -312,3 +313,57 @@ impl<A: ?Sized> Lens<A, A> for Id {
         f(data)
     }
 }
+
+/// A `Lens` that exposes data within an `Arc` with copy-on-write semantics
+///
+/// A copy is only made in the event that a different value is written.
+#[derive(Debug, Copy, Clone)]
+pub struct MakeMut<L, M, B> {
+    arc: L,
+    inner: M,
+    _marker: PhantomData<B>,
+}
+
+impl<L, M, B> MakeMut<L, M, B> {
+    /// Construct a lens manipulating the `inner` part of `arc`
+    ///
+    /// See also `LensExt::make_mut`
+    pub fn new<A, C>(arc: L, inner: M) -> Self
+    where
+        A: ?Sized,
+        B: Clone,
+        C: Data,
+        L: Lens<A, Arc<B>>,
+        M: Lens<B, C>,
+    {
+        Self {
+            arc,
+            inner,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<A, B, C, L, M> Lens<A, C> for MakeMut<L, M, B>
+where
+    A: ?Sized,
+    B: Clone,
+    C: Data,
+    L: Lens<A, Arc<B>>,
+    M: Lens<B, C>,
+{
+    fn with<V, F: FnOnce(&C) -> V>(&self, data: &A, f: F) -> V {
+        self.arc.with(data, |arc| self.inner.with(arc, f))
+    }
+
+    fn with_mut<V, F: FnOnce(&mut C) -> V>(&self, data: &mut A, f: F) -> V {
+        self.arc.with_mut(data, |arc| {
+            let mut temp = self.inner.with(arc, |x| x.clone());
+            let v = f(&mut temp);
+            if self.inner.with(arc, |x| !x.same(&temp)) {
+                self.inner.with_mut(&mut Arc::make_mut(arc), |x| *x = temp);
+            }
+            v
+        })
+    }
+}

druid/src/lens_ext.rs

@@ -1,6 +1,8 @@
 use std::ops;
+use std::sync::Arc;
 
-use crate::lens::{Deref, Index, Then};
+use crate::data::Data;
+use crate::lens::{Deref, Index, MakeMut, Then};
 use crate::Lens;
 
 /// Helpers for manipulating `Lens`es
@@ -68,6 +70,33 @@ pub trait LensExt<A: ?Sized, B: ?Sized>: Lens<A, B> {
     {
         self.then(Index::new(index))
     }
+
+    /// Access data in an `Arc` with copy-on-write semantics
+    ///
+    /// The inner `lens` allows the scope that has to be checked for changes after a mutable access
+    /// to be reduced.
+    ///
+    /// ```
+    /// # use druid::*; use std::sync::Arc;
+    /// let lens = lens::Id.make_mut(lens::Id.index(2));
+    /// let mut x = Arc::new(vec![0, 1, 2, 3]);
+    /// let original = x.clone();
+    /// assert_eq!(lens.get(&x), 2);
+    /// lens.set(&mut x, 2);
+    /// assert!(Arc::ptr_eq(&original, &x), "no-op writes don't force a clone");
+    /// lens.set(&mut x, 42);
+    /// assert_eq!(&*x, &[0, 1, 42, 3]);
+    /// ```
+    fn make_mut<L, C, D>(self, lens: L) -> MakeMut<Self, L, C>
+    where
+        Self: Sized + Lens<A, Arc<C>>,
+        B: Sized,
+        C: Clone,
+        D: Data,
+        L: Lens<C, D>,
+    {
+        MakeMut::new(self, lens)
+    }
 }
 
 impl<A: ?Sized, B: ?Sized, T: Lens<A, B>> LensExt<A, B> for T {}