[wip] store api overhaul

lib/puppy/src/lib.rs

@@ -30,7 +30,7 @@ pub fn create_post(db: &Store, author: Key, content: impl ToString) -> store::Re
             content: Some(content.to_string()),
             summary: None,
         })?;
-        tx.insert_arrow((author, key), AuthorOf)?;
+        tx.insert_arrow::<AuthorOf>((author, key))?;
         Ok(key)
     })
 }
@@ -131,7 +131,7 @@ pub mod fr {
 
     pub fn create(db: &Store, requester: Key, target: Key) -> store::Result<()> {
         db.transaction(|tx| {
-            tx.insert_arrow((requester, target), FollowRequested)?;
+            tx.insert_arrow::<FollowRequested>((requester, target))?;
             OK
         })
     }
@@ -139,7 +139,7 @@ pub mod fr {
     pub fn accept(db: &Store, requester: Key, target: Key) -> store::Result<()> {
         db.transaction(|tx| {
             tx.remove_arrow::<FollowRequested>((requester, target))?;
-            tx.insert_arrow((requester, target), Follows)?;
+            tx.insert_arrow::<Follows>((requester, target))?;
             OK
         })
     }

lib/store/src/arrow.rs

@@ -44,7 +44,8 @@ pub mod multi {
 }
 
 /// A directed edge between two vertices.
-pub trait Arrow: Encode + Decode {
+pub trait Arrow {
+    type Label: Encode + Decode = ();
     const SPACE: (Space, Space);
 }
 
@@ -55,7 +56,6 @@ pub enum Direction {
 }
 
 /// The node this arrow points away from is the "author" of the node the arrow points to.
-#[derive(Encode, Decode)]
 pub struct AuthorOf;
 
 impl Arrow for AuthorOf {
@@ -63,7 +63,6 @@ impl Arrow for AuthorOf {
 }
 
 /// The origin of this arrow has follow requested the target.
-#[derive(Encode, Decode)]
 pub struct FollowRequested;
 
 impl Arrow for FollowRequested {
@@ -71,7 +70,6 @@ impl Arrow for FollowRequested {
 }
 
 /// The origin "follows" the target.
-#[derive(Encode, Decode)]
 pub struct Follows;
 
 impl Arrow for Follows {

lib/store/src/transaction.rs

@@ -203,7 +203,7 @@ impl Transaction<'_> {
 
 impl Transaction<'_> {
     /// Find an arrow of type `A` with the given `tail` and `head`.
-    pub fn lookup_arrow<A>(&self, (tail, head): (Key, Key)) -> Result<Option<A>>
+    pub fn lookup_arrow<A>(&self, (tail, head): (Key, Key)) -> Result<Option<A::Label>>
     where
         A: Arrow,
     {
@@ -214,14 +214,14 @@ impl Transaction<'_> {
             Err(err) => Err(err),
         }
     }
-    /// Create a new arrow of type `A` and associate the label with it.
+    /// Create a simple arrow of type `A`.
     ///
     /// # Errors
     ///
     /// - `Error::Undefined` if either key is not registered
-    pub fn insert_arrow<A>(&self, (tail, head): (Key, Key), label: A) -> Result<()>
+    pub fn insert_arrow<A>(&self, (tail, head): (Key, Key)) -> Result<()>
     where
-        A: Arrow,
+        A: Arrow<Label = ()>,
     {
         if !self.is_registered(tail)? {
             return Err(Error::Undefined { key: tail });
@@ -230,9 +230,8 @@ impl Transaction<'_> {
             return Err(Error::Undefined { key: head });
         }
         let (l, r) = A::SPACE;
-        let label = encode(label)?;
+        self.with(l).set(tail.fuse(head), b"")?;
-        self.with(l).set(tail.fuse(head), &label)?;
+        self.with(r).set(head.fuse(tail), b"")?;
-        self.with(r).set(head.fuse(tail), &label)?;
         OK
     }
     /// Delete an arrow from the data store.
@@ -252,21 +251,27 @@ impl Transaction<'_> {
         self.with(A::SPACE.0).has(tail.fuse(head))
     }
     /// Get all arrows of type `A` "pointing at" `key`.
-    pub fn list_incoming<A>(&self, key: impl Keylike) -> impl Iterator<Item = Result<(Key, A)>> + '_
+    pub fn list_incoming<A>(
+        &self,
+        key: impl Keylike,
+    ) -> impl Iterator<Item = Result<(Key, A::Label)>> + '_
     where
         A: Arrow,
     {
-        self.list_arrows_where(Direction::Incoming, key)
+        self.list_arrows_where::<A>(Direction::Incoming, key)
     }
     /// Get all arrows of type `A` "pointing away from" `key`.
-    pub fn list_outgoing<A>(&self, key: impl Keylike) -> impl Iterator<Item = Result<(Key, A)>> + '_
+    pub fn list_outgoing<A>(
+        &self,
+        key: impl Keylike,
+    ) -> impl Iterator<Item = Result<(Key, A::Label)>> + '_
     where
         A: Arrow,
     {
-        self.list_arrows_where(Direction::Outgoing, key)
+        self.list_arrows_where::<A>(Direction::Outgoing, key)
     }
     /// Get all arrows of type `A`.
-    pub fn list_arrows<A>(&self) -> impl Iterator<Item = Result<(Key, A, Key)>> + '_
+    pub fn list_arrows<A>(&self) -> impl Iterator<Item = Result<(Key, A::Label, Key)>> + '_
     where
         A: Arrow,
     {
@@ -280,7 +285,7 @@ impl Transaction<'_> {
         &self,
         direction: Direction,
         key: impl Keylike,
-    ) -> impl Iterator<Item = Result<(Key, A)>> + '_
+    ) -> impl Iterator<Item = Result<(Key, A::Label)>> + '_
     where
         A: Arrow,
     {

lib/store/src/transaction/tests.rs

@@ -34,7 +34,7 @@ fn with_test_arrow(f: impl Fn(Key, Key, &Transaction<'_>, usize) -> Result<()>)
                 tx.create_vertex(target, TEST_TAG)?;
                 tx.create_vertex(origin, TEST_TAG)?;
 
-                tx.insert_arrow((origin, target), TestArrow)?;
+                tx.insert_arrow::<TestArrow>((origin, target))?;
 
                 let l: Vec<String> = tx
                     .with("test-arrow/l")
@@ -126,7 +126,7 @@ fn fanout() -> Result<()> {
             tx.create_vertex(origin, TEST_TAG)?;
             for t in targets {
                 tx.create_vertex(t, TEST_TAG)?;
-                tx.insert_arrow((origin, t), TestArrow)?;
+                tx.insert_arrow::<TestArrow>((origin, t))?;
             }
 
             let oo: Vec<_> = tx.list_outgoing::<TestArrow>(origin).keys().try_collect()?;
@@ -154,7 +154,7 @@ fn fanin() -> Result<()> {
             tx.create_vertex(target, TEST_TAG)?;
             for o in origins {
                 tx.create_vertex(o, TEST_TAG)?;
-                tx.insert_arrow((o, target), TestArrow)?;
+                tx.insert_arrow::<TestArrow>((o, target))?;
             }
 
             let ti: Vec<_> = tx.list_incoming::<TestArrow>(target).keys().try_collect()?;
@@ -185,7 +185,7 @@ fn distinct_many_to_many() -> Result<()> {
             for o in origins {
                 tx.create_vertex(o, TEST_TAG)?;
                 for t in targets {
-                    tx.insert_arrow((o, t), TestArrow)?;
+                    tx.insert_arrow::<TestArrow>((o, t))?;
                 }
             }