generate and mode functionality for substantial relation

2 files changed, 28 insertions, 10 deletions

diff --git a/lib/kernel/SubstantialRelation.ml b/lib/kernel/SubstantialRelation.ml
index 0afc3f7..0176928 100644
--- a/lib/kernel/SubstantialRelation.ml
+++ b/lib/kernel/SubstantialRelation.ml
@@ -127,7 +127,7 @@ module Make (S : Abstract.Storage.STORAGE) = struct
              (fun acc (name, domain) -> BatMap.String.add name domain acc)
              BatMap.String.empty kvs)
 
-  let enumerate storage relation =
+  let scan storage relation ~keep =
     let open Utilities.Result in
     let* tx = S.start storage in
     let* node = tuple_node tx relation in
@@ -137,12 +137,26 @@ module Make (S : Abstract.Storage.STORAGE) = struct
        and one tuple at a time rather than materialized before the
        first tuple is produced. *)
     let produce ~yield =
-      let walked = TupleSet.iter tx (fun _ tuple -> yield tuple) node in
+      let walked = TupleSet.iter tx (fun _ tuple -> if keep tuple then yield tuple) node in
       close ();
       walked
     in
     Ok (Generator.cursor_of ~on_release:close produce)
 
+  let enumerate storage relation = scan storage relation ~keep:(fun _ -> true)
+
+  let generate storage relation binding =
+    scan storage relation ~keep:(Protocols.Generative.satisfies binding)
+
+  let modes tx relation =
+    let open Utilities.Result in
+    let* description = schema_of tx relation in
+    let labels = BatMap.String.keys description |> BatList.of_enum in
+    Ok
+      (Concepts.Mode.of_list
+         [ Concepts.Mode.enumerable Concepts.Cardinality.Finite;
+           Concepts.Mode.decides_when labels ] )
+
   class relation storage value =
     object (self)
       inherit Lifecycle.null
@@ -168,9 +182,13 @@ module Make (S : Abstract.Storage.STORAGE) = struct
          no name resolution, but cancellation should eventually be checked between tuples. *)
       method enumerate = enumerate storage relation
 
+      method modes = SI.with_transaction storage (fun tx -> modes tx relation)
+      method generate binding = generate storage relation binding
+
       method protocols : Protocols.Handle.protocol list =
         [ Protocols.Relation.make self
         ; Protocols.Enumerable.make self
+        ; Protocols.Generative.make self
         ; Protocols.Schematics.make self ]
       method hash = hash relation
     end
diff --git a/lib/kernel/SubstantialRelation.mli b/lib/kernel/SubstantialRelation.mli
index 5061e5d..73a06c7 100644
--- a/lib/kernel/SubstantialRelation.mli
+++ b/lib/kernel/SubstantialRelation.mli
@@ -47,18 +47,18 @@ module Make (S : Abstract.Storage.STORAGE) : sig
   val contains_tuple :
     S.transaction -> t -> Concepts.Tuple.t -> (bool, Concepts.Condition.condition) result
 
-  (** decodes the schematics at [schematics relation] -- the body of
-      [Protocols.Schematics.describe] for this kind of relation. *)
   val schema_of :
     S.transaction ->
     t ->
     (Protocols.Schematics.relation_description, Concepts.Condition.condition) result
 
-  (** a handle carrying [Protocols.Cursor] over every tuple currently
-      asserted, decoded via [Concepts.Tuple.Representation.of_blob] --
-      the body of [Protocols.Relation.enumerate] for this kind of
-      relation. Opens its own storage transaction, held for the
-      cursor's whole lifetime rather than just this call -- see
-      [Kernel.Generator] and docs/design/evaluator.md, "Shape". *)
   val enumerate : S.connection -> t -> (Protocols.Handle.t, Concepts.Condition.condition) result
+
+  val generate :
+    S.connection ->
+    t ->
+    Protocols.Generative.binding ->
+    (Protocols.Handle.t, Concepts.Condition.condition) result
+
+  val modes : S.transaction -> t -> (Concepts.Mode.t, Concepts.Condition.condition) result
 end