From 742fcf6793e1a38d4cf65bf72832847c0fd679b4 Mon Sep 17 00:00:00 2001
From: LLLL Colonq <llll@colonq>
Date: Thu, 8 Oct 2026 06:02:58 -0400
Subject: Add semi-naive Datalog evaluation

---
 crates/elfmind/src/knowledge/relation.rs | 80 ++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

(limited to 'crates/elfmind/src/knowledge/relation.rs')

diff --git a/crates/elfmind/src/knowledge/relation.rs b/crates/elfmind/src/knowledge/relation.rs
index 754bf0f..b738aa1 100644
--- a/crates/elfmind/src/knowledge/relation.rs
+++ b/crates/elfmind/src/knowledge/relation.rs
@@ -7,6 +7,76 @@ use crate::character::*;
 use enum_map::Enum;
 use strum::EnumDiscriminants;
 
+pub trait Concretizable {
+    type Concrete;
+    fn concretize(&self) -> Option<Self::Concrete>;
+}
+impl<A: Clone> Concretizable for Hole<A> {
+    type Concrete = A;
+    fn concretize(&self) -> Option<Self::Concrete> {
+        match self {
+            Self::Val(x) => Some(x.clone()),
+            _ => None,
+        }
+    }
+}
+impl<
+    A: Clone,
+    B: Clone,
+    > Concretizable for (Hole<A>, Hole<B>) {
+    type Concrete = (A, B);
+    fn concretize(&self) -> Option<Self::Concrete> {
+        let a = self.0.concretize()?;
+        let b = self.1.concretize()?;
+        Some((a, b))
+    }
+}
+impl<
+    A: Clone,
+    B: Clone,
+    C: Clone,
+    > Concretizable for (Hole<A>, Hole<B>, Hole<C>) {
+        type Concrete = (A, B, C);
+    fn concretize(&self) -> Option<Self::Concrete> {
+        let a = self.0.concretize()?;
+        let b = self.1.concretize()?;
+        let c = self.2.concretize()?;
+        Some((a, b, c))
+    }
+}
+impl<
+    A: Clone,
+    B: Clone,
+    C: Clone,
+    D: Clone,
+    > Concretizable for (Hole<A>, Hole<B>, Hole<C>, Hole<D>) {
+        type Concrete = (A, B, C, D);
+    fn concretize(&self) -> Option<Self::Concrete> {
+        let a = self.0.concretize()?;
+        let b = self.1.concretize()?;
+        let c = self.2.concretize()?;
+        let d = self.3.concretize()?;
+        Some((a, b, c, d))
+    }
+}
+impl<
+    A: Clone,
+    B: Clone,
+    C: Clone,
+    D: Clone,
+    E: Clone,
+    > Concretizable for (Hole<A>, Hole<B>, Hole<C>, Hole<D>, Hole<E>) {
+        type Concrete = (A, B, C, D, E);
+    fn concretize(&self) -> Option<Self::Concrete> {
+        let a = self.0.concretize()?;
+        let b = self.1.concretize()?;
+        let c = self.2.concretize()?;
+        let d = self.3.concretize()?;
+        let e = self.4.concretize()?;
+        Some((a, b, c, d, e))
+    }
+}
+
 pub trait Substitutable {
     fn substitute(&self, u: &Unification) -> Self;
 }
@@ -140,6 +210,16 @@ pub enum Relation {
     TimeIs(Hole<Time>),
     FriendOf((Hole<Character>, Hole<Character>)),
 }
+impl Relation {
+    pub fn is_concrete(&self) -> bool {
+        match self {
+            Self::HasItem(x) => x.concretize().is_some(),
+            Self::UsedItemAt(x) => x.concretize().is_some(),
+            Self::TimeIs(x) => x.concretize().is_some(),
+            Self::FriendOf(x) => x.concretize().is_some(),
+        }
+    }
+}
 impl Substitutable for Relation {
     fn substitute(&self, u: &Unification) -> Self {
         match self {
-- 
cgit v1.3.1