Deref and Index lenses

Author: Ralith

druid/src/lens.rs

@@ -15,6 +15,7 @@
 //! Support for lenses, a way of focusing on subfields of data.
 
 use std::marker::PhantomData;
+use std::ops;
 
 pub use druid_derive::Lens;
 
@@ -252,3 +253,82 @@ impl<T: Clone, U: Clone, B> Clone for Then<T, U, B> {
         }
     }
 }
+
+#[derive(Debug, Copy, Clone)]
+pub struct Deref;
+
+impl<T: ?Sized> Lens<T, T::Target> for Deref
+where T: ops::Deref + ops::DerefMut,
+{
+    fn with<V, F: FnOnce(&T::Target) -> V>(&self, data: &T, f: F) -> V {
+        f(data.deref())
+    }
+    fn with_mut<V, F: FnOnce(&mut T::Target) -> V>(&self, data: &mut T, f: F) -> V {
+        f(data.deref_mut())
+    }
+}
+
+/// `Lens` for indexing containers
+#[derive(Debug, Copy, Clone)]
+pub struct Index<I> {
+    index: I,
+}
+
+impl<I> Index<I> {
+    /// Construct a lens that accesses a particular index
+    ///
+    /// See also `LensExt::index`.
+    pub fn new(index: I) -> Self {
+        Self { index }
+    }
+}
+
+impl<T, I> Lens<T, T::Output> for Index<I>
+where
+    T: ?Sized + ops::Index<I> + ops::IndexMut<I>,
+    I: Clone,
+{
+    fn with<V, F: FnOnce(&T::Output) -> V>(&self, data: &T, f: F) -> V {
+        f(&data[self.index.clone()])
+    }
+    fn with_mut<V, F: FnOnce(&mut T::Output) -> V>(&self, data: &mut T, f: F) -> V {
+        f(&mut data[self.index.clone()])
+    }
+}
+
+pub trait Iso<A, B> {
+    fn forward_ref(&self, a: &A) -> B;
+    fn reverse_ref(&self, b: &B) -> A;
+
+    fn forward(&self, a: A) -> B {
+        self.forward_ref(&a)
+    }
+
+    fn reverse(&self, b: B) -> A {
+        self.reverse_ref(&b)
+    }
+
+    fn into_lens(self) -> IsoLens<Self>
+    where Self: Sized
+    {
+        IsoLens { iso: self }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct IsoLens<I> {
+    iso: I,
+}
+
+impl<A, B, I: Iso<A, B>> Lens<A, B> for IsoLens<I> {
+    fn with<T, F: FnOnce(&B) -> T>(&self, data: &A, f: F) -> T {
+        f(&self.iso.forward_ref(data))
+    }
+
+    fn with_mut<T, F: FnOnce(&mut B) -> T>(&self, data: &mut A, f: F) -> T {
+        let mut x = self.iso.forward_ref(data);
+        let v = f(&mut x);
+        *data = self.iso.reverse(x);
+        v
+    }
+}

druid/src/lens_ext.rs

@@ -1,4 +1,6 @@
-use crate::lens::Then;
+use std::ops;
+
+use crate::lens::{Index, Then, Deref};
 use crate::Lens;
 
 /// Helpers for manipulating `Lens`es
@@ -35,6 +37,37 @@ pub trait LensExt<A: ?Sized, B: ?Sized>: Lens<A, B> {
     {
         Then::new(self, other)
     }
+
+    /// Invoke a type's `Deref` impl
+    ///
+    /// ```
+    /// # use druid::*;
+    /// let lens = lens!((bool, Box<u32>), 1).deref();
+    /// assert_eq!(lens.get(&(false, Box::new(42))), 42);
+    /// ```
+    fn deref(self) -> Then<Self, Deref, B>
+    where
+        B: ops::Deref + ops::DerefMut,
+        Self: Sized,
+    {
+        self.then(Deref)
+    }
+
+    /// Access an index in a container
+    ///
+    /// ```
+    /// # use druid::*;
+    /// let lens = lens!((bool, Vec<u8>), 1).deref().index(2);
+    /// assert_eq!(lens.get(&(false, vec![0, 1, 2, 3])), 2);
+    /// ```
+    fn index<I>(self, index: I) -> Then<Self, Index<I>, B>
+    where
+        I: Clone,
+        B: ops::Index<I> + ops::IndexMut<I>,
+        Self: Sized,
+    {
+        self.then(Index::new(index))
+    }
 }
 
 impl<A: ?Sized, B: ?Sized, T: Lens<A, B>> LensExt<A, B> for T {}