Improve the decoupling and the API #1

Author: habedi

AGENTS.md

@@ -41,7 +41,6 @@ Priorities, in order:
 - `src/zodd/extend.zig`: Leaper-based extension primitives (`ExtendWith`, `FilterAnti`, `ExtendAnti`, `extendInto`).
 - `src/zodd/index.zig`: Indexes for keyed lookups.
 - `src/zodd/aggregate.zig`: Group-by and aggregation operations.
-- `src/zodd/context.zig`: `ExecutionContext` (allocator and shared state for a Datalog run).
 - `tests/`: Non-unit tests (`integration_tests.zig`, `regression_tests.zig`, `property_tests.zig`, `incremental_tests.zig`).
 - `examples/`: Self-contained example programs (`e1_network_reachability.zig` through `e6_dependency_resolution.zig`) built as executables via
   `build.zig`.
@@ -54,10 +53,10 @@ Priorities, in order:
 
 ### Evaluation Pipeline
 
-A Datalog program flows through: `ExecutionContext` (`context.zig`) owns the allocator and shared state. Base data is loaded into a `Relation`
-(`relation.zig`). Derived predicates use a `Variable` (`variable.zig`) driven by an `Iteration` (`iteration.zig`) loop that calls `changed()` until a
-fixed point. Each iteration extends tuples via `join` (`join.zig`) or `extend` (`extend.zig`), optionally using indexes (`index.zig`) or aggregates
-(`aggregate.zig`).
+A Datalog program flows through: base data is loaded into a `Relation` (`relation.zig`). Derived predicates use a `Variable` (`variable.zig`) driven
+by an `Iteration` (`iteration.zig`) loop that calls `changed()` until a fixed point. Each iteration extends tuples via `join` (`join.zig`) or `extend`
+(`extend.zig`), optionally using indexes (`index.zig`) or aggregates (`aggregate.zig`). Every primitive takes a `std.mem.Allocator` directly; there is
+no wrapper context type.
 
 ### Relations and Variables Split
 

README.md

@@ -132,46 +132,39 @@ pub fn main() !void {
     var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
-    var ctx = zodd.ExecutionContext.init(allocator);
-    defer ctx.deinit();
 
     const Edge = struct { u32, u32 };
 
-    // Create base relation: edges in a graph
-    var edges = try zodd.Relation(Edge).fromSlice(&ctx, &[_]Edge{
+    // Base relation: edges in a graph
+    var edges = try zodd.Relation(Edge).fromSlice(allocator, &[_]Edge{
         .{ 1, 2 },
         .{ 2, 3 },
         .{ 3, 4 },
     });
     defer edges.deinit();
 
-    // Create variable for reachability (transitive closure)
-    var reachable = zodd.Variable(Edge).init(&ctx);
+    // Variable holding the reachability closure
+    var reachable = zodd.Variable(Edge).init(allocator);
     defer reachable.deinit();
+    try reachable.insertSlice(edges.elements);
 
-    // Initialize with base edges
-    try reachable.insertSlice(&ctx, edges.elements);
-
-    // Fixed-point iteration: reachable(X,Z) :- reachable(X,Y), edge(Y,Z)
+    // Fixed-point iteration: reachable(X, Z) :- reachable(X, Y), edge(Y, Z)
     while (try reachable.changed()) {
-        var new_tuples: std.ArrayList(Edge) = .empty;
-        defer new_tuples.deinit(allocator);
+        var batch: std.ArrayList(Edge) = .empty;
+        defer batch.deinit(allocator);
 
         for (reachable.recent.elements) |r| {
             for (edges.elements) |e| {
-                if (e[0] == r[1]) {
-                    try new_tuples.append(allocator, .{ r[0], e[1] });
-                }
+                if (e[0] == r[1]) try batch.append(allocator, .{ r[0], e[1] });
             }
         }
 
-        if (new_tuples.items.len > 0) {
-            const rel = try zodd.Relation(Edge).fromSlice(&ctx, new_tuples.items);
+        if (batch.items.len > 0) {
+            const rel = try zodd.Relation(Edge).fromSlice(allocator, batch.items);
             try reachable.insert(rel);
         }
     }
 
-    // Get final result
     var result = try reachable.complete();
     defer result.deinit();
 

examples/e1_network_reachability.zig

@@ -18,7 +18,6 @@ pub fn main() !void {
     var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
-    var ctx = zodd.ExecutionContext.init(allocator);
 
     std.debug.print("Zodd Datalog Engine - Network Reachability Analysis\n", .{});
     std.debug.print("===================================================\n\n", .{});
@@ -87,20 +86,20 @@ pub fn main() !void {
 
     // -- Build relations --
 
-    var links = try zodd.Relation(Pair).fromSlice(&ctx, &link_data);
+    var links = try zodd.Relation(Pair).fromSlice(allocator, &link_data);
     defer links.deinit();
 
-    var blocked = try zodd.Relation(Pair).fromSlice(&ctx, &blocked_data);
+    var blocked = try zodd.Relation(Pair).fromSlice(allocator, &blocked_data);
     defer blocked.deinit();
 
     // -- Step 1: Compute reachable zones (transitive routing) --
     //   reachable(A, B) :- link(A, B).
     //   reachable(A, C) :- reachable(A, B), link(B, C).
 
-    var reachable = zodd.Variable(Pair).init(&ctx);
+    var reachable = zodd.Variable(Pair).init(allocator);
     defer reachable.deinit();
 
-    try reachable.insertSlice(&ctx, links.elements);
+    try reachable.insertSlice(links.elements);
 
     std.debug.print("\nComputing transitive reachability...\n", .{});
 
@@ -119,7 +118,7 @@ pub fn main() !void {
         }
 
         if (results.items.len > 0) {
-            const rel = try zodd.Relation(Pair).fromSlice(&ctx, results.items);
+            const rel = try zodd.Relation(Pair).fromSlice(allocator, results.items);
             try reachable.insert(rel);
         }
 

examples/e2_knowledge_graph.zig

@@ -18,7 +18,6 @@ pub fn main() !void {
     var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
-    var ctx = zodd.ExecutionContext.init(allocator);
 
     std.debug.print("Zodd Datalog Engine - Knowledge Graph Reasoning\n", .{});
     std.debug.print("================================================\n\n", .{});
@@ -117,24 +116,24 @@ pub fn main() !void {
 
     // -- Build relations --
 
-    var is_a_rel = try zodd.Relation(Pair).fromSlice(&ctx, &is_a_data);
+    var is_a_rel = try zodd.Relation(Pair).fromSlice(allocator, &is_a_data);
     defer is_a_rel.deinit();
 
-    var symptom_rel = try zodd.Relation(Pair).fromSlice(&ctx, &symptom_data);
+    var symptom_rel = try zodd.Relation(Pair).fromSlice(allocator, &symptom_data);
     defer symptom_rel.deinit();
 
-    var targets_rel = try zodd.Relation(Pair).fromSlice(&ctx, &targets_data);
+    var targets_rel = try zodd.Relation(Pair).fromSlice(allocator, &targets_data);
     defer targets_rel.deinit();
 
-    var assoc_rel = try zodd.Relation(Pair).fromSlice(&ctx, &assoc_data);
+    var assoc_rel = try zodd.Relation(Pair).fromSlice(allocator, &assoc_data);
     defer assoc_rel.deinit();
 
     // -- Step 1: Compute transitive type hierarchy --
     //   is_a(X, Z) :- is_a(X, Y), is_a(Y, Z).
 
-    var is_a = zodd.Variable(Pair).init(&ctx);
+    var is_a = zodd.Variable(Pair).init(allocator);
     defer is_a.deinit();
-    try is_a.insertSlice(&ctx, is_a_rel.elements);
+    try is_a.insertSlice(is_a_rel.elements);
 
     std.debug.print("\nComputing transitive type hierarchy...\n", .{});
 
@@ -153,7 +152,7 @@ pub fn main() !void {
         }
 
         if (results.items.len > 0) {
-            const rel = try zodd.Relation(Pair).fromSlice(&ctx, results.items);
+            const rel = try zodd.Relation(Pair).fromSlice(allocator, results.items);
             try is_a.insert(rel);
         }
         if (iter > 50) break;
@@ -170,9 +169,9 @@ pub fn main() !void {
     // -- Step 2: Inherit symptoms through type hierarchy --
     //   has_symptom(D, S) :- is_a(D, D2), has_symptom(D2, S).
 
-    var has_symptom = zodd.Variable(Pair).init(&ctx);
+    var has_symptom = zodd.Variable(Pair).init(allocator);
     defer has_symptom.deinit();
-    try has_symptom.insertSlice(&ctx, symptom_rel.elements);
+    try has_symptom.insertSlice(symptom_rel.elements);
 
     // For each is_a(D, D2), propagate symptoms from D2 to D
     {
@@ -198,7 +197,7 @@ pub fn main() !void {
         }
 
         if (inherited.items.len > 0) {
-            try has_symptom.insertSlice(&ctx, inherited.items);
+            try has_symptom.insertSlice(inherited.items);
         }
     }
     _ = try has_symptom.changed();
@@ -217,29 +216,29 @@ pub fn main() !void {
     // Join key = Protein. targets is (Drug, Protein), assoc is (Protein, Disease).
     // Rekey targets as (Protein, Drug) to align the join key.
 
-    var targets_by_protein = zodd.Variable(Pair).init(&ctx);
+    var targets_by_protein = zodd.Variable(Pair).init(allocator);
     defer targets_by_protein.deinit();
     {
         var flipped = PairList.empty;
         defer flipped.deinit(allocator);
         for (targets_rel.elements) |t| {
             try flipped.append(allocator, .{ t[1], t[0] }); // (Protein, Drug)
         }
-        try targets_by_protein.insertSlice(&ctx, flipped.items);
+        try targets_by_protein.insertSlice(flipped.items);
         _ = try targets_by_protein.changed();
     }
 
-    var assoc_var = zodd.Variable(Pair).init(&ctx);
+    var assoc_var = zodd.Variable(Pair).init(allocator);
     defer assoc_var.deinit();
-    try assoc_var.insertSlice(&ctx, assoc_rel.elements);
+    try assoc_var.insertSlice(assoc_rel.elements);
     _ = try assoc_var.changed();
 
     const Triple = struct { u32, u32, u32 };
-    var treats_triple = zodd.Variable(Triple).init(&ctx);
+    var treats_triple = zodd.Variable(Triple).init(allocator);
     defer treats_triple.deinit();
 
     // joinInto: key=Protein, val1=Drug, val2=Disease
-    try zodd.joinInto(u32, u32, u32, Triple, &ctx, &targets_by_protein, &assoc_var, &treats_triple, struct {
+    try zodd.joinInto(u32, u32, u32, Triple, &targets_by_protein, &assoc_var, &treats_triple, struct {
         fn logic(_: *const u32, drug: *const u32, disease: *const u32) Triple {
             return .{ drug.*, disease.*, 0 };
         }

examples/e3_data_lineage.zig

@@ -18,7 +18,6 @@ pub fn main() !void {
     var gpa = std.heap.DebugAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
-    var ctx = zodd.ExecutionContext.init(allocator);
 
     std.debug.print("Zodd Datalog Engine - Data Lineage for Compliance\n", .{});
     std.debug.print("=================================================\n\n", .{});
@@ -130,25 +129,25 @@ pub fn main() !void {
 
     // -- Build relations --
 
-    var transforms = try zodd.Relation(Pair).fromSlice(&ctx, &transform_data);
+    var transforms = try zodd.Relation(Pair).fromSlice(allocator, &transform_data);
     defer transforms.deinit();
 
-    var anonymizes = try zodd.Relation(Pair).fromSlice(&ctx, &anonymize_data);
+    var anonymizes = try zodd.Relation(Pair).fromSlice(allocator, &anonymize_data);
     defer anonymizes.deinit();
 
     // -- Step 1: Propagate PII through the pipeline --
     //   contains_pii(D) :- source_pii(D).
     //   contains_pii(D2) :- contains_pii(D1), transform(D1, D2),
     //                        NOT anonymizes(D1, D2).
 
-    var contains_pii = zodd.Variable(Scalar).init(&ctx);
+    var contains_pii = zodd.Variable(Scalar).init(allocator);
     defer contains_pii.deinit();
-    try contains_pii.insertSlice(&ctx, &source_pii_data);
+    try contains_pii.insertSlice(&source_pii_data);
 
     std.debug.print("\nPropagating PII through ETL pipeline...\n", .{});
 
     // Use ExtendWith to propose destinations for PII-containing datasets
-    var extend = zodd.ExtendWith(Scalar, u32, u32).init(&ctx, &transforms, &struct {
+    var extend = zodd.ExtendWith(Scalar, u32, u32).init(allocator, &transforms, &struct {
         fn key(tuple: *const Scalar) u32 {
             return tuple[0];
         }
@@ -159,7 +158,7 @@ pub fn main() !void {
         std.debug.print("  Iteration {}: {} datasets with PII\n", .{ iteration, contains_pii.recent.len() });
 
         // Use extendInto to find downstream datasets
-        var proposed = zodd.Variable(Pair).init(&ctx);
+        var proposed = zodd.Variable(Pair).init(allocator);
         defer proposed.deinit();
 
         const leaper = extend.leaper();
@@ -169,7 +168,6 @@ pub fn main() !void {
             Scalar,
             u32,
             Pair,
-            &ctx,
             &contains_pii,
             &leapers,
             &proposed,
@@ -203,7 +201,7 @@ pub fn main() !void {
         }
 
         if (new_pii.items.len > 0) {
-            const rel = try zodd.Relation(Scalar).fromSlice(&ctx, new_pii.items);
+            const rel = try zodd.Relation(Scalar).fromSlice(allocator, new_pii.items);
             try contains_pii.insert(rel);
         }