From 09ff5f929853cc2ba1a1ed7ddb20566cd8fe021d Mon Sep 17 00:00:00 2001
From: LLLL Colonq <llll@colonq>
Date: Fri, 11 Sep 2026 15:47:34 -0400
Subject: More Datalog

---
 Cargo.lock                               |   8 ++
 Cargo.toml                               |   6 +-
 crates/elfmacros/Cargo.toml              |  12 +++
 crates/elfmacros/src/lib.rs              |   0
 crates/elfmind/src/knowledge.rs          |  74 +++-----------
 crates/elfmind/src/knowledge/relation.rs | 163 +++++++++++++++++++++++++++++++
 crates/elfmind/src/lib.rs                |   1 +
 crates/elfmind/src/main.rs               |  24 ++---
 crates/elfmind/src/time.rs               |   1 +
 9 files changed, 214 insertions(+), 75 deletions(-)
 create mode 100644 crates/elfmacros/Cargo.toml
 create mode 100644 crates/elfmacros/src/lib.rs
 create mode 100644 crates/elfmind/src/knowledge/relation.rs
 create mode 100644 crates/elfmind/src/time.rs

diff --git a/Cargo.lock b/Cargo.lock
index 29ac8cf..5894d4f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -768,6 +768,14 @@ version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
 
+[[package]]
+name = "elfmacros"
+version = "0.1.0"
+dependencies = [
+ "quote",
+ "syn 3.0.5",
+]
+
 [[package]]
 name = "elfmind"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index d47243b..694bb91 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,13 +34,15 @@ teleia_macros = { path = "../teleia/crates/teleia_macros" } # engine
 bitflags = { version = "2.6.0", features = ["serde"] } # bitwise flags
 rand = { version = "=0.8.5", features = ["small_rng"] } # rng
 log = "0.4.21" # logging
-lazy_static = "*" # global constants
+lazy_static = "1.5.0" # global constants
 bimap = {version = "0.6.3", features = ["serde"]} # bijective maps
 strum = {version = "0.27.1", features = ["derive"]} # utility macros for enums
 enum-map = {version = "2.7.3", features = ["serde"]} # enum map
 serde = { version = "1.0.228", features = ["derive"] } # serialization
 bincode = {version = "2.0.1", features = ["serde"]} # binary serialization
-itertools = "*" # iterator tools
+itertools = "0.15.0" # iterator tools
+syn = "3.0.5" # parser for proc macros
+quote = "1.0.47" # quasiquotation for proc macros
 
 # cfg(target_arch = "wasm32")
 wasm-bindgen = "=0.2.100" # wasm bindings
diff --git a/crates/elfmacros/Cargo.toml b/crates/elfmacros/Cargo.toml
new file mode 100644
index 0000000..9c97e8d
--- /dev/null
+++ b/crates/elfmacros/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "elfmacros"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = { workspace = true }
\ No newline at end of file
diff --git a/crates/elfmacros/src/lib.rs b/crates/elfmacros/src/lib.rs
new file mode 100644
index 0000000..e69de29
diff --git a/crates/elfmind/src/knowledge.rs b/crates/elfmind/src/knowledge.rs
index 3b90dee..cbcce28 100644
--- a/crates/elfmind/src/knowledge.rs
+++ b/crates/elfmind/src/knowledge.rs
@@ -1,12 +1,15 @@
-use std::collections::{HashMap, HashSet};
-use itertools::Itertools;
+pub mod relation;
+pub use relation::*;
 
-use enum_map::{Enum, EnumMap};
+use crate::time::*;
+use crate::item::*;
+use crate::character::*;
 
-use crate::item::Item;
-use crate::character::Character;
+use std::collections::{HashMap, HashSet};
+use itertools::Itertools;
 
-type Time = u64;
+use enum_map::EnumMap;
+use strum::IntoDiscriminant;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Var { index: u64 }
@@ -100,57 +103,6 @@ impl<T: Clone + TryFrom<Value>> Hole<T> {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Enum)]
-pub enum RelationSort {
-    HasItem,
-    UsedItemAt,
-    TimeIs,
-    FriendOf,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Relation {
-    HasItem(Hole<Character>, Hole<Item>),
-    UsedItemAt(Hole<Character>, Hole<Item>, Hole<Time>),
-    TimeIs(Hole<Time>),
-    FriendOf(Hole<Character>, Hole<Character>),
-}
-impl Relation {
-    pub fn sort(&self) -> RelationSort {
-        match self {
-            Self::HasItem{..} => RelationSort::HasItem,
-            Self::UsedItemAt{..} => RelationSort::UsedItemAt,
-            Self::TimeIs{..} => RelationSort::TimeIs,
-            Self::FriendOf{..} => RelationSort::FriendOf,
-        }
-    }
-    pub fn unify(&self, other: &Self, mut u: Unification) -> Option<Unification> {
-        match (self, other) {
-            (Self::HasItem(c1, i1), Self::HasItem(c2, i2))
-              if u.unify_hole(c1, c2) && u.unify_hole(i1, i2)
-              => Some(u),
-            (Self::UsedItemAt(c1, i1, t1), Self::UsedItemAt(c2, i2, t2))
-              if u.unify_hole(c1, c2) && u.unify_hole(i1, i2) && u.unify_hole(t1, t2)
-              => Some(u),
-            (Self::TimeIs(t1), Self::TimeIs(t2))
-              if u.unify_hole(t1, t2)
-              => Some(u),
-            (Self::FriendOf(x1, y1), Self::FriendOf(x2, y2))
-              if u.unify_hole(x1, x2) && u.unify_hole(y1, y2)
-              => Some(u),
-            _ => None,
-        }
-    }
-    pub fn substitute(&self, u: &Unification) -> Self {
-        match self {
-            Self::HasItem(c, i) => Self::HasItem(c.substitute(u), i.substitute(u)),
-            Self::UsedItemAt(c, i, t) => Self::UsedItemAt(c.substitute(u), i.substitute(u), t.substitute(u)),
-            Self::TimeIs(t) => Self::TimeIs(t.substitute(u)),
-            Self::FriendOf(x, y) => Self::FriendOf(x.substitute(u), y.substitute(u)),
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct Rule {
     pub head: Relation,
@@ -169,13 +121,13 @@ impl Rule {
 
 #[derive(Debug, Default, Clone)]
 pub struct Facts {
-    facts: EnumMap<RelationSort, HashSet<Relation>>,
+    facts: EnumMap<RelationDiscriminants, HashSet<Relation>>,
 }
 impl Facts {
     pub fn add(&mut self, f: Relation) -> bool {
-        self.facts[f.sort()].insert(f)
+        self.facts[f.discriminant()].insert(f)
     }
-    pub fn with_sort(&self, s: RelationSort) -> &HashSet<Relation> {
+    pub fn with_sort(&self, s: RelationDiscriminants) -> &HashSet<Relation> {
         &self.facts[s]
     }
 }
@@ -190,7 +142,7 @@ impl Database {
     pub fn add_rule(&mut self, r: Rule) { self.rules.push(r) }
     fn apply_rule(r: &Rule, facts: &mut Facts) -> bool {
         let found: Vec<Unification> = r.body.iter()
-            .map(|r| facts.with_sort(r.sort())).multi_cartesian_product()
+            .map(|r| facts.with_sort(r.discriminant())).multi_cartesian_product()
             .filter_map(|fs| r.unify_body(&fs))
             .collect();
         let mut changed = false;
diff --git a/crates/elfmind/src/knowledge/relation.rs b/crates/elfmind/src/knowledge/relation.rs
new file mode 100644
index 0000000..754bf0f
--- /dev/null
+++ b/crates/elfmind/src/knowledge/relation.rs
@@ -0,0 +1,163 @@
+use super::{Value, Hole, Unification};
+
+use crate::time::*;
+use crate::item::*;
+use crate::character::*;
+
+use enum_map::Enum;
+use strum::EnumDiscriminants;
+
+pub trait Substitutable {
+    fn substitute(&self, u: &Unification) -> Self;
+}
+impl<A: Clone + TryFrom<Value>> Substitutable for Hole<A> {
+    fn substitute(&self, u: &Unification) -> Self {
+        match self {
+            x@Self::Var(v) => if let Some(y) = u.lookup(v) && let Ok(z) = A::try_from(y) {
+                Hole::Val(z)
+            } else {
+                x.clone()
+            }
+            x => x.clone(),
+        }
+    }
+}
+impl<
+    A: Clone + TryFrom<Value>,
+    B: Clone + TryFrom<Value>
+    > Substitutable for (Hole<A>, Hole<B>) {
+    fn substitute(&self, u: &Unification) -> Self {
+        let (a, b) = self;
+        (a.substitute(u), b.substitute(u))
+    }
+}
+impl<
+    A: Clone + TryFrom<Value>,
+    B: Clone + TryFrom<Value>,
+    C: Clone + TryFrom<Value>,
+    > Substitutable for (Hole<A>, Hole<B>, Hole<C>) {
+    fn substitute(&self, u: &Unification) -> Self {
+        let (a, b, c) = self;
+        (a.substitute(u), b.substitute(u), c.substitute(u))
+    }
+}
+impl<
+    A: Clone + TryFrom<Value>,
+    B: Clone + TryFrom<Value>,
+    C: Clone + TryFrom<Value>,
+    D: Clone + TryFrom<Value>,
+    > Substitutable for (Hole<A>, Hole<B>, Hole<C>, Hole<D>) {
+    fn substitute(&self, u: &Unification) -> Self {
+        let (a, b, c, d) = self;
+        (a.substitute(u), b.substitute(u), c.substitute(u), d.substitute(u))
+    }
+}
+impl<
+    A: Clone + TryFrom<Value>,
+    B: Clone + TryFrom<Value>,
+    C: Clone + TryFrom<Value>,
+    D: Clone + TryFrom<Value>,
+    E: Clone + TryFrom<Value>,
+    > Substitutable for (Hole<A>, Hole<B>, Hole<C>, Hole<D>, Hole<E>) {
+    fn substitute(&self, u: &Unification) -> Self {
+        let (a, b, c, d, e) = self;
+        (a.substitute(u), b.substitute(u), c.substitute(u), d.substitute(u), e.substitute(u))
+    }
+}
+
+pub trait Unifiable {
+    fn unify(&self, other: &Self, u: Unification) -> Option<Unification>;
+}
+impl<A> Unifiable for Hole<A> where
+    Value: From<A>, A: Copy, 
+{
+    fn unify(&self, other: &Self, mut u: Unification) -> Option<Unification> {
+        if u.unify_hole(self, other) {
+            Some(u)
+        } else { None }
+    }
+}
+impl<A, B> Unifiable for (Hole<A>, Hole<B>) where
+    Value: From<A>, A: Copy, 
+    Value: From<B>, B: Copy,
+{
+    fn unify(&self, other: &Self, mut u: Unification) -> Option<Unification> {
+        let (a1, b1) = self;
+        let (a2, b2) = other;
+        if u.unify_hole(a1, a2) && u.unify_hole(b1, b2) {
+            Some(u)
+        } else { None }
+    }
+}
+impl<A, B, C> Unifiable for (Hole<A>, Hole<B>, Hole<C>) where
+    Value: From<A>, A: Copy, 
+    Value: From<B>, B: Copy,
+    Value: From<C>, C: Copy,
+{
+    fn unify(&self, other: &Self, mut u: Unification) -> Option<Unification> {
+        let (a1, b1, c1) = self;
+        let (a2, b2, c2) = other;
+        if u.unify_hole(a1, a2) && u.unify_hole(b1, b2) && u.unify_hole(c1, c2) {
+            Some(u)
+        } else { None }
+    }
+}
+impl<A, B, C, D> Unifiable for (Hole<A>, Hole<B>, Hole<C>, Hole<D>) where
+    Value: From<A>, A: Copy, 
+    Value: From<B>, B: Copy,
+    Value: From<C>, C: Copy,
+    Value: From<D>, D: Copy,
+{
+    fn unify(&self, other: &Self, mut u: Unification) -> Option<Unification> {
+        let (a1, b1, c1, d1) = self;
+        let (a2, b2, c2, d2) = other;
+        if u.unify_hole(a1, a2) && u.unify_hole(b1, b2) && u.unify_hole(c1, c2) && u.unify_hole(d1, d2) {
+            Some(u)
+        } else { None }
+    }
+}
+impl<A, B, C, D, E> Unifiable for (Hole<A>, Hole<B>, Hole<C>, Hole<D>, Hole<E>) where
+    Value: From<A>, A: Copy, 
+    Value: From<B>, B: Copy,
+    Value: From<C>, C: Copy,
+    Value: From<D>, D: Copy,
+    Value: From<E>, E: Copy,
+{
+    fn unify(&self, other: &Self, mut u: Unification) -> Option<Unification> {
+        let (a1, b1, c1, d1, e1) = self;
+        let (a2, b2, c2, d2, e2) = other;
+        if u.unify_hole(a1, a2) && u.unify_hole(b1, b2) && u.unify_hole(c1, c2) && u.unify_hole(d1, d2) && u.unify_hole(e1, e2) {
+            Some(u)
+        } else { None }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, EnumDiscriminants)]
+#[strum_discriminants(derive(Enum))]
+pub enum Relation {
+    HasItem((Hole<Character>, Hole<Item>)),
+    UsedItemAt((Hole<Character>, Hole<Item>, Hole<Time>)),
+    TimeIs(Hole<Time>),
+    FriendOf((Hole<Character>, Hole<Character>)),
+}
+impl Substitutable for Relation {
+    fn substitute(&self, u: &Unification) -> Self {
+        match self {
+            Self::HasItem(x) => Self::HasItem(x.substitute(u)),
+            Self::UsedItemAt(x) => Self::UsedItemAt(x.substitute(u)),
+            Self::TimeIs(x) => Self::TimeIs(x.substitute(u)),
+            Self::FriendOf(x) => Self::FriendOf(x.substitute(u)),
+        }
+    }
+}
+impl Unifiable for Relation {
+    fn unify(&self, other: &Self, u: Unification) -> Option<Unification> {
+        match (self, other) {
+            (Self::HasItem(a), Self::HasItem(b)) => a.unify(b, u),
+            (Self::UsedItemAt(a), Self::UsedItemAt(b)) => a.unify(b, u),
+            (Self::TimeIs(a), Self::TimeIs(b)) => a.unify(b, u),
+            (Self::FriendOf(a), Self::FriendOf(b)) => a.unify(b, u),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/elfmind/src/lib.rs b/crates/elfmind/src/lib.rs
index ba9eeb4..30167b4 100644
--- a/crates/elfmind/src/lib.rs
+++ b/crates/elfmind/src/lib.rs
@@ -1,3 +1,4 @@
+pub mod time;
 pub mod item;
 pub mod knowledge;
 // pub mod gadget;
diff --git a/crates/elfmind/src/main.rs b/crates/elfmind/src/main.rs
index 748ca9d..cd811f7 100644
--- a/crates/elfmind/src/main.rs
+++ b/crates/elfmind/src/main.rs
@@ -6,44 +6,44 @@ fn main() {
     let mut db = Database::default();
     db.add_fact(Relation::TimeIs(Hole::Val(6)));
     db.add_fact(Relation::TimeIs(Hole::Val(7)));
-    db.add_fact(Relation::HasItem(Hole::Val(character::Character::Tyumici), Hole::Val(item::Item::Apple)));
-    db.add_fact(Relation::FriendOf(Hole::Val(character::Character::Bobo), Hole::Val(character::Character::Naesten)));
+    db.add_fact(Relation::HasItem((Hole::Val(character::Character::Tyumici), Hole::Val(item::Item::Apple))));
+    db.add_fact(Relation::FriendOf((Hole::Val(character::Character::Bobo), Hole::Val(character::Character::Naesten))));
     let vt = ctx.var("time");
     let vi = ctx.var("item");
     db.add_rule(Rule {
-        head: Relation::UsedItemAt(
+        head: Relation::UsedItemAt((
             Hole::Val(character::Character::Tyumici),
             Hole::Var(vi),
             Hole::Var(vt),
-        ),
+        )),
         body: vec![
             Relation::TimeIs(Hole::Var(vt)),
-            Relation::HasItem(Hole::Val(character::Character::Tyumici), Hole::Var(vi)),
+            Relation::HasItem((Hole::Val(character::Character::Tyumici), Hole::Var(vi))),
         ],
     });
     let vt = ctx.var("time");
     let vc = ctx.var("char");
     db.add_rule(Rule {
-        head: Relation::FriendOf(
+        head: Relation::FriendOf((
             Hole::Val(character::Character::Naesten),
             Hole::Var(vc),
-        ),
+        )),
         body: vec![
             Relation::TimeIs(Hole::Var(vt)),
-            Relation::UsedItemAt(Hole::Var(vc), Hole::Val(item::Item::Apple), Hole::Var(vt)),
+            Relation::UsedItemAt((Hole::Var(vc), Hole::Val(item::Item::Apple), Hole::Var(vt))),
         ],
     });
     let vc1 = ctx.var("char");
     let vc2 = ctx.var("char");
     let vc3 = ctx.var("char");
     db.add_rule(Rule {
-        head: Relation::FriendOf(
+        head: Relation::FriendOf((
             Hole::Var(vc1),
             Hole::Var(vc3),
-        ),
+        )),
         body: vec![
-            Relation::FriendOf(Hole::Var(vc1), Hole::Var(vc2)),
-            Relation::FriendOf(Hole::Var(vc2), Hole::Var(vc3)),
+            Relation::FriendOf((Hole::Var(vc1), Hole::Var(vc2))),
+            Relation::FriendOf((Hole::Var(vc2), Hole::Var(vc3))),
         ],
     });
     db.apply_rules();
diff --git a/crates/elfmind/src/time.rs b/crates/elfmind/src/time.rs
new file mode 100644
index 0000000..5a98630
--- /dev/null
+++ b/crates/elfmind/src/time.rs
@@ -0,0 +1 @@
+pub type Time = u64;
-- 
cgit v1.3.1