Add yoke crate

Author: Manishearth

Cargo.lock

@@ -29,6 +29,7 @@ members = [
     "utils/litemap",
     "utils/pattern",
     "utils/writeable",
+    "utils/yoke",
     "utils/zerovec",
 ]
 

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "yoke"
+version = "0.1.0"
+authors = ["Manish Goregaokar <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

utils/yoke/Cargo.toml

@@ -0,0 +1,9 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+mod yoke;
+mod yokeable;
+
+pub use yoke::Yoke;
+pub use yokeable::Yokeable;

utils/yoke/src/lib.rs

@@ -0,0 +1,58 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::Yokeable;
+use std::rc::Rc;
+
+pub struct Yoke<Y: for<'a> Yokeable<'a>, C> {
+    // must be the first field for drop order
+    // this will have a 'static lifetime parameter, that parameter is a lie
+    yokeable: Y,
+    cart: C,
+}
+
+impl<Y: for<'a> Yokeable<'a>, C> Yoke<Y, C> {
+    pub fn new(cart: C, yokeable: Y) -> Self {
+        Self { yokeable, cart }
+    }
+    pub fn get<'a>(&'a self) -> &'a <Y as Yokeable<'a>>::Output {
+        self.yokeable.transform()
+    }
+
+    pub fn backing_cart(&self) -> &C {
+        &self.cart
+    }
+
+    pub fn with_mut<'a, F>(&'a mut self, f: F)
+    where
+        F: 'static + FnOnce(&'a mut <Y as Yokeable<'a>>::Output),
+    {
+        self.yokeable.with_mut(f)
+    }
+}
+
+impl<Y: for<'a> Yokeable<'a>, C> Yoke<Y, C> {
+    pub fn attach_to_cart<F>(cart: C, f: F) -> Self
+    where
+        for<'de> F: FnOnce(&'de C) -> <Y as Yokeable<'de>>::Output,
+    {
+        let deserialized = f(&cart);
+        Self {
+            yokeable: unsafe { Y::make(deserialized) },
+            cart,
+        }
+    }
+}
+
+impl<Y: for<'a> Yokeable<'a>, T: ?Sized> Clone for Yoke<Y, Rc<T>>
+where
+    for<'a> <Y as Yokeable<'a>>::Output: Clone,
+{
+    fn clone(&self) -> Self {
+        Yoke {
+            yokeable: unsafe { Y::make(self.get().clone()) },
+            cart: self.cart.clone(),
+        }
+    }
+}

utils/yoke/src/yoke.rs

@@ -0,0 +1,62 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use std::borrow::{Cow, ToOwned};
+use std::mem;
+
+pub unsafe trait Yokeable<'a>: 'static {
+    type Output: 'a + Sized; // MUST be `Self` with the lifetime swapped
+                             // used by `SharedData::get()`
+    fn transform(&'a self) -> &'a Self::Output;
+
+    // Used for zero-copy deserialization. Safety constraint: `Self` must be
+    // destroyed before the data `Self::Output` was deserialized
+    // from is
+    unsafe fn make(from: Self::Output) -> Self;
+
+    fn with_mut<F>(&'a mut self, f: F)
+    where
+        F: 'static + FnOnce(&'a mut Self::Output);
+}
+
+unsafe impl<'a, T: 'static + ToOwned + ?Sized> Yokeable<'a> for Cow<'static, T>
+where
+    <T as ToOwned>::Owned: Sized,
+{
+    type Output = Cow<'a, T>;
+    fn transform(&'a self) -> &'a Cow<'a, T> {
+        self
+    }
+
+    unsafe fn make(from: Cow<'a, T>) -> Self {
+        debug_assert!(mem::size_of::<Cow<'a, T>>() == mem::size_of::<Self>());
+        // i hate this
+        // unfortunately Rust doesn't think `mem::transmute` is possible since it's not sure the sizes
+        // are the same
+        mem::transmute_copy(&from)
+    }
+
+    fn with_mut<F>(&'a mut self, f: F)
+    where
+        F: 'static + FnOnce(&'a mut Self::Output),
+    {
+        unsafe { f(mem::transmute(self)) }
+    }
+}
+
+struct Foo {
+    str: String,
+    cow: Cow<'static, str>,
+}
+
+// The following code should NOT compile!!!
+//
+// fn unsound<'a>(foo: &'a mut Foo) {
+//     let a: &str = &foo.str;
+//     foo.cow.with_mut(|cow| *cow = Cow::Borrowed(a));
+// }
+
+fn sound<'a>(foo: &'a mut Foo) {
+    foo.cow.with_mut(move |cow| cow.to_mut().push('a'));
+}