First idea

Author: laurmaedje

.gitignore

@@ -0,0 +1,4 @@
+.vscode
+.DS_Store
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "comemo"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+comemo-macros = { path = "./macros" }

macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "comemo-macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "1", features = ["full"] }

macros/src/lib.rs

@@ -0,0 +1,67 @@
+extern crate proc_macro;
+
+macro_rules! bail {
+    ($item:expr, $fmt:literal $($tts:tt)*) => {
+        return Err(Error::new_spanned(
+            &$item,
+            format!(concat!("comemo: ", $fmt) $($tts)*)
+        ))
+    }
+}
+
+mod memoize;
+mod track;
+
+use proc_macro::TokenStream;
+use quote::{quote, quote_spanned};
+use syn::spanned::Spanned;
+use syn::{parse_quote, Error, Result};
+
+/// Memoize a pure function.
+///
+/// ```
+/// #[memoize]
+/// fn describe(image: Tracked<Image>) -> String {
+///     let w = image.width();
+///     let h = image.height();
+///     format!("The image is {w}x{h} pixels.")
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn memoize(_: TokenStream, stream: TokenStream) -> TokenStream {
+    let func = syn::parse_macro_input!(stream as syn::ItemFn);
+    memoize::expand(func)
+        .unwrap_or_else(|err| err.to_compile_error())
+        .into()
+}
+
+/// Make a type trackable.
+///
+/// ```
+/// /// A decoded raster image.
+/// pub struct Image {
+///     width: u32,
+///     height: u32,
+///     pixels: Vec<u8>,
+/// }
+///
+/// #[track]
+/// impl Image {
+///     fn width(&self) -> u32 {
+///         self.width
+///     }
+///
+///     fn height(&self) -> u32 {
+///         self.height
+///     }
+/// }
+/// ```
+///
+/// [`Track`]: ../comemo/trait.Track.html
+#[proc_macro_attribute]
+pub fn track(_: TokenStream, stream: TokenStream) -> TokenStream {
+    let block = syn::parse_macro_input!(stream as syn::ItemImpl);
+    track::expand(block)
+        .unwrap_or_else(|err| err.to_compile_error())
+        .into()
+}

macros/src/memoize.rs

@@ -0,0 +1,33 @@
+use super::*;
+
+/// Make a type trackable.
+pub fn expand(mut func: syn::ItemFn) -> Result<proc_macro2::TokenStream> {
+    let name = func.sig.ident.to_string();
+
+    let mut args = vec![];
+    let mut asserts = vec![];
+    for input in &func.sig.inputs {
+        let typed = match input {
+            syn::FnArg::Typed(typed) => typed,
+            syn::FnArg::Receiver(_) => {
+                bail!(input, "methods are not supported")
+            }
+        };
+
+        let ident = match &*typed.pat {
+            syn::Pat::Ident(ident) => ident,
+            _ => bail!(typed.pat, "only simple identifiers are supported"),
+        };
+
+        asserts.push(quote_spanned! { ident.span() => assert_hash(&#ident); });
+        args.push(ident);
+    }
+
+    func.block.stmts.insert(0, parse_quote! { {
+        println!("calling {}", #name);
+        fn assert_hash<T: std::hash::Hash>(_: &T) {}
+        // #(#asserts)*
+    } });
+
+    Ok(quote! { #func })
+}

macros/src/track.rs

@@ -0,0 +1,67 @@
+use super::*;
+
+/// Make a type trackable.
+pub fn expand(block: syn::ItemImpl) -> Result<proc_macro2::TokenStream> {
+    let ty = &block.self_ty;
+
+    let mut tracked_methods = vec![];
+    for item in &block.items {
+        let method = match item {
+            syn::ImplItem::Method(method) => method,
+            _ => bail!(item, "only methods are supported"),
+        };
+
+        let mut tracked = method.clone();
+        let name = &tracked.sig.ident;
+
+        let mut inputs = tracked.sig.inputs.iter();
+        let receiver = match inputs.next() {
+            Some(syn::FnArg::Receiver(recv)) => recv,
+            _ => bail!(tracked, "method must take self"),
+        };
+
+        if receiver.reference.is_none() || receiver.mutability.is_some() {
+            bail!(receiver, "must take self by shared reference");
+        }
+
+        let mut args = vec![];
+        for input in inputs {
+            let pat = match input {
+                syn::FnArg::Typed(typed) => &*typed.pat,
+                syn::FnArg::Receiver(_) => unreachable!("unexpected second self"),
+            };
+
+            let ident = match pat {
+                syn::Pat::Ident(ident) => ident,
+                _ => bail!(pat, "only simple identifiers are supported"),
+            };
+
+            args.push(ident);
+        }
+
+        tracked.block = parse_quote! { { self.0.#name(#(#args),*) } };
+        tracked_methods.push(tracked);
+    }
+
+    let track_impl = quote! {
+        impl comemo::Track for #ty {
+            type Surface = Surface;
+
+            fn surface(&self) -> &Surface {
+                unsafe { &*(self as *const Self as *const Surface) }
+            }
+        }
+
+        #[repr(transparent)]
+        struct Surface(#ty);
+
+        impl Surface {
+            #(#tracked_methods)*
+        }
+    };
+
+    Ok(quote! {
+        #block
+        const _: () = { #track_impl };
+    })
+}

rustfmt.toml

@@ -0,0 +1,11 @@
+unstable_features = true
+
+overflow_delimited_expr = true
+spaces_around_ranges = true
+use_field_init_shorthand = true
+merge_derives = false
+
+max_width = 90
+struct_lit_width = 40
+chain_width = 70
+single_line_if_else_max_width = 60

src/lib.rs

@@ -0,0 +1,55 @@
+/*!
+Tracked memoization.
+*/
+
+pub use comemo_macros::{memoize, track};
+
+use std::ops::Deref;
+
+/// Tracks accesses to a value.
+///
+/// Encapsulates a reference to a value and tracks all accesses to it.
+/// The only methods accessible on `Tracked<T>` are those defined in an impl
+/// block for `T` annotated with [`#[track]`](track).
+///
+/// ```
+/// use comemo::Track;
+///
+/// let image = Image::random(20, 40);
+/// let sentence = describe(image.track());
+/// println!("{sentence}");
+/// ```
+pub struct Tracked<'a, T>(&'a T)
+where
+    T: Track;
+
+/// A trackable type.
+pub trait Track: Sized {
+    /// Start tracking a value.
+    fn track(&self) -> Tracked<Self> {
+        Tracked(self)
+    }
+
+    /// The tracked API surface of the type.
+    ///
+    /// This is an implementation detail, which shouldn't directly be used.
+    #[doc(hidden)]
+    type Surface;
+
+    /// Access the tracked API surface.
+    ///
+    /// This is an implementation detail, which shouldn't directly be used.
+    #[doc(hidden)]
+    fn surface(&self) -> &Self::Surface;
+}
+
+impl<'a, T> Deref for Tracked<'a, T>
+where
+    T: Track,
+{
+    type Target = T::Surface;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.surface()
+    }
+}

src/main.rs

@@ -0,0 +1,87 @@
+use comemo::{Track, Tracked};
+
+#[rustfmt::skip]
+fn main() {
+    let fonts = Fonts(vec![
+        Face { name: "mathup", style: Style::Normal },
+        Face { name: "mathbf", style: Style::Bold },
+        Face { name: "mathit", style: Style::Italic },
+    ]);
+
+    let par = Paragraph(vec![
+        Segment { text: "HELLO ".into(), font: "mathup" },
+        Segment { text: "WORLD".into(), font: "mathit" },
+    ]);
+
+    let shaped = shape(&par, fonts.track());
+    println!("{shaped}");
+
+    let shaped = shape(&par, fonts.track());
+    println!("{shaped}");
+}
+
+/// Shape a piece of text with fonts.
+#[comemo::memoize]
+fn shape(par: &Paragraph, fonts: Tracked<Fonts>) -> String {
+    let mut shaped = String::new();
+    for piece in &par.0 {
+        let font = fonts.get(&piece.font).unwrap();
+        for c in piece.text.chars() {
+            shaped.push(font.map(c));
+        }
+    }
+    shaped
+}
+
+/// A paragraph of text in different fonts.
+#[derive(Debug, Clone, Hash)]
+struct Paragraph(Vec<Segment>);
+
+/// A segment of text with consistent font.
+#[derive(Debug, Clone, Hash)]
+struct Segment {
+    text: String,
+    font: &'static str,
+}
+
+/// A font database.
+struct Fonts(Vec<Face>);
+
+#[comemo::track]
+impl Fonts {
+    /// Select a face by family name.
+    fn get(&self, family: &str) -> Option<&Face> {
+        self.0.iter().find(|font| font.name == family)
+    }
+}
+
+/// A font face.
+#[derive(Debug, Clone, Hash)]
+struct Face {
+    name: &'static str,
+    style: Style,
+}
+
+/// The style of a font face.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+enum Style {
+    Normal,
+    Bold,
+    Italic,
+}
+
+impl Face {
+    fn map(&self, c: char) -> char {
+        let base = match self.style {
+            Style::Normal => 0x41,
+            Style::Bold => 0x1D400,
+            Style::Italic => 0x1D434,
+        };
+
+        if c.is_ascii_alphabetic() {
+            std::char::from_u32(base + (c as u32 - 0x41)).unwrap()
+        } else {
+            c
+        }
+    }
+}