aboutsummaryrefslogtreecommitdiffstats
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/evaluators/FOL.ml118
-rw-r--r--lib/evaluators/Lambda.ml105
-rw-r--r--lib/kernel/EphemeralRelation.ml46
-rw-r--r--lib/kernel/EphemeralRelation.mli36
-rw-r--r--lib/kernel/Multigroup.ml2
-rw-r--r--lib/kernel/SubstantialRelation.ml130
-rw-r--r--lib/kernel/SubstantialRelation.mli55
-rw-r--r--lib/protocols/Evaluator.ml11
-rw-r--r--lib/protocols/Evaluator.mli10
-rw-r--r--lib/protocols/Program.ml16
-rw-r--r--lib/protocols/Program.mli15
-rw-r--r--lib/protocols/Relation.ml4
-rw-r--r--lib/protocols/Relation.mli9
13 files changed, 182 insertions, 375 deletions
diff --git a/lib/evaluators/FOL.ml b/lib/evaluators/FOL.ml
index 4299524..016e3a0 100644
--- a/lib/evaluators/FOL.ml
+++ b/lib/evaluators/FOL.ml
@@ -7,32 +7,124 @@ module Error = struct
let cancelled () =
condition "evaluation-cancelled" "An evaluation was stopped before it produced its result" empty
+
+ let not_a_plan name =
+ condition "not-a-fol-program" "The evaluator was given an object that carries no FOL plan"
+ ("object" |=| Concepts.Value.String name)
+
+ let not_a_relation name =
+ condition "not-a-relation" "A plan named an object that does not describe itself as a relation"
+ ("object" |=| Concepts.Value.String name)
+
+ let unknown_attribute name =
+ condition "unknown-attribute" "A plan projected an attribute its relation does not have"
+ ("attribute" |=| Concepts.Value.String name)
+
+ let released_relation name =
+ condition "released-relation" "A plan named a relation that was already released"
+ ("object" |=| Concepts.Value.String name)
end
type plan = Base of Protocols.Handle.t | Project of plan * string BatFingerTree.t
+type Protocols.Handle.protocol += Plan of plan
+
+class program plan =
+ object
+ inherit Kernel.Lifecycle.null
+ inherit Kernel.Identity.of_id
+ method to_string = "fol-program"
+ method protocols : Protocols.Handle.protocol list = [Plan plan]
+ end
-module Program = Protocols.Program.Make (struct
- type t = plan
-end)
+let program plan = new program plan |> Protocols.Handle.make
+
+let restrict attributes description =
+ let open Utilities.Result in
+ BatFingerTree.fold_left
+ (fun restricted name ->
+ let* restricted = restricted in
+ let* attribute =
+ BatMap.String.find_opt name description
+ |> Option.to_result ~none:(Error.unknown_attribute name)
+ in
+ Ok (BatMap.String.add name attribute restricted) )
+ (Ok BatMap.String.empty) attributes
-let execute =
+let rec describe =
let open Utilities.Result in
function
- | Base relation_handle ->
- Fun.protect
- ~finally:(fun () -> Protocols.Handle.release relation_handle)
- (fun () ->
- let* enumerable = Protocols.Enumerable.require relation_handle in
- Protocols.Enumerable.enumerate enumerable )
- | Project (_plan, _attributes) -> failwith "TODO"
+ | Base relation -> (
+ let* schematics = Protocols.Handle.require Protocols.Schematics.from relation in
+ let* description = Protocols.Schematics.describe schematics in
+ match description with
+ | Protocols.Schematics.Relation description -> Ok description
+ | _ -> Error (Error.not_a_relation (Protocols.Handle.to_string relation)) )
+ | Project (plan, attributes) -> describe plan |> fmap (restrict attributes)
+
+let enumerate relation =
+ let open Utilities.Result in
+ let* enumerable = Protocols.Enumerable.require relation in
+ Protocols.Enumerable.enumerate enumerable
+
+let project description relation =
+ let open Utilities.Result in
+ let* cursor = enumerate relation in
+ let produce ~yield =
+ let* scan = Protocols.Cursor.require cursor in
+ let rec distinct seen =
+ let* next = Protocols.Cursor.next scan in
+ match next with
+ | None -> Ok ()
+ | Some tuple ->
+ let tuple =
+ { tuple with
+ attributes=
+ BatMap.String.filter
+ (fun name _ -> BatMap.String.mem name description)
+ tuple.Concepts.Tuple.attributes }
+ in
+ let key = Concepts.Tuple.hash tuple |> Concepts.Hash.to_raw_string in
+ if BatSet.String.mem key seen then distinct seen
+ else begin
+ yield tuple;
+ distinct (BatSet.String.add key seen)
+ end
+ in
+ distinct BatSet.String.empty
+ in
+ Ok (Kernel.Generator.cursor_of ~finally:(fun () -> Protocols.Handle.release cursor) produce)
+
+let derive relation description enumerate =
+ Kernel.EphemeralRelation.instantiate ~inputs:[relation] description
+ {Kernel.EphemeralRelation.schematics= `Temporary description}
+ (fun () -> enumerate relation)
+
+let rec execute plan =
+ let open Utilities.Result in
+ let* description = describe plan in
+ match plan with
+ | Base relation ->
+ let* relation =
+ Protocols.Handle.copy relation
+ |> Option.to_result ~none:(Error.released_relation (Protocols.Handle.to_string relation))
+ in
+ Ok (derive relation description enumerate)
+ | Project (plan, _) ->
+ let* relation = execute plan in
+ Ok (derive relation description (project description))
class evaluator =
object (self)
inherit Kernel.Lifecycle.null
inherit Kernel.Identity.of_id
method to_string = "fol-evaluator"
- method invoke = execute
- method protocols : Protocols.Handle.protocol list = [Program.make self]
+
+ method invoke program =
+ Protocols.Handle.into program (function Plan plan -> Some plan | _ -> None)
+ |> Option.to_result ~none:(Error.not_a_plan (Protocols.Handle.to_string program))
+ |> Utilities.Result.fmap (fun plan -> Protocols.Handle.invoke plan execute)
+
+ method protocols : Protocols.Handle.protocol list = [Protocols.Evaluator.make self]
end
let make () = new evaluator |> Protocols.Handle.make
diff --git a/lib/evaluators/Lambda.ml b/lib/evaluators/Lambda.ml
deleted file mode 100644
index d864ca1..0000000
--- a/lib/evaluators/Lambda.ml
+++ /dev/null
@@ -1,105 +0,0 @@
-module Error = struct
- open Concepts.Condition
-
- let unknown_name name =
- condition "unknown-name"
- "A term named neither a bound variable nor a relation existing under this snapshot"
- ("name" |=| Concepts.Value.String name)
-
- let not_applicable () =
- condition "not-applicable"
- "A term was applied to an argument, but it denotes a relation rather than an abstraction"
- empty
-
- let unapplied_abstraction () =
- condition "unapplied-abstraction"
- "A program reduced to an abstraction, which names no relation to enumerate" empty
-
- let cancelled () =
- condition "evaluation-cancelled" "An evaluation was stopped before it produced its result" empty
-end
-
-(* A dummy untyped lambda calculus where constants are relations. We
- look for a name in the environment first and resolved through the
- context otherwise, so the relations reachable under the snapshot
- are the outer environment every program is evaluated on *)
-type term = Name of string | Abstract of string * term | Apply of term * term
-type program = Program of term * Protocols.Directory.t Protocols.Handle.interface
-
-module Program = Protocols.Program.Make (struct
- type t = program
-end)
-
-type value = Relation of Protocols.Handle.t | Closure of string * term * environment
-and environment = value BatMap.String.t
-
-(* let reduce context term = *)
-(* let open Utilities.Result in *)
-(* let rec eval environment term = *)
-(* match context.Protocols.Context.status () with *)
-(* | `Cancelled | `Exhausted -> Error (Error.cancelled ()) *)
-(* | `Live -> *)
-(* match term with *)
-(* | Name name -> *)
-(* begin match BatMap.String.find_opt name environment with *)
-(* | Some value -> Ok value *)
-(* | None -> *)
-(* let* found = Runtime.Context.resolve context name in *)
-(* let* handle = Option.to_result ~none:(Error.unknown_name name) found in *)
-(* Ok (Relation handle) *)
-(* end *)
-(* | Abstract (binder, body) -> Ok (Closure (binder, body, environment)) *)
-(* | Apply (operator, operand) -> *)
-(* let* operator = eval environment operator in *)
-(* match operator with *)
-(* | Relation _ -> Error (Error.not_applicable ()) *)
-(* | Closure (binder, body, closed) -> *)
-(* let* argument = eval environment operand in *)
-(* eval (BatMap.String.add binder argument closed) body *)
-(* in *)
-(* eval BatMap.String.empty term *)
-
-let reduce (Program (term, dir)) =
- let open Utilities.Result in
- let open Protocols in
- let rec eval env term =
- match term with
- | Name name ->
- begin match BatMap.String.find_opt name env with
- | Some value -> Ok value
- | None ->
- let* handle =
- Directory.find dir name |> fmap (Option.to_result ~none:(Error.unknown_name name))
- in
- Ok (Relation handle)
- end
- | Abstract (binder, body) -> Ok (Closure (binder, body, env))
- | Apply (operator, operand) -> (
- let* operator = eval env operator in
- match operator with
- | Relation _ -> Error (Error.not_applicable ())
- | Closure (binder, body, closed) ->
- let* argument = eval env operand in
- eval (BatMap.String.add binder argument closed) body )
- in
- eval BatMap.String.empty term
-
-let execute term =
- let open Utilities.Result in
- let* value = reduce term in
- match value with
- | Closure _ -> Error (Error.unapplied_abstraction ())
- | Relation handle ->
- let* enumerable = Protocols.Enumerable.require handle in
- Protocols.Enumerable.enumerate enumerable
-
-class evaluator =
- object (self)
- inherit Kernel.Lifecycle.null
- inherit Kernel.Identity.of_id
- method to_string = "lambda-evaluator"
- method invoke program = execute program
- method protocols : Protocols.Handle.protocol list = [Program.make self]
- end
-
-let make () = new evaluator |> Protocols.Handle.make
diff --git a/lib/kernel/EphemeralRelation.ml b/lib/kernel/EphemeralRelation.ml
index ddf005d..e1e450d 100644
--- a/lib/kernel/EphemeralRelation.ml
+++ b/lib/kernel/EphemeralRelation.ml
@@ -1,29 +1,35 @@
type t =
- { schematics: [`Persisted of Concepts.Hash.hash
- | `Temporary of (Protocols.Schematics.attribute_description BatMap.String.t) ] }
+ { schematics:
+ [ `Persisted of Concepts.Hash.hash
+ | `Temporary of Protocols.Schematics.attribute_description BatMap.String.t ] }
module Error = struct
- open Concepts.Condition
- let local_constraint_not_implemented =
- condition "local-constraint-not-implemented"
- "Local constraints have no centralized authority for their discerniment and enforcement yet."
- empty
- let predicate_not_implemented =
- condition "predicate-not-implemented"
- "Preciate descriptions for relations is not designed yet."
- empty
+ (* open Concepts.Condition *)
end
-class ephemeral_relation program address value =
+class ephemeral_relation description value enumerate inputs =
object (self)
- inherit Lifecycle.null
+ inherit Lifecycle.counted
+ inherit Identity.of_id
+ method to_string = "ephemeral-relation"
val relation : t = value
- method local_constraints = Error Error.local_constraint_not_implemented
- method predicate = Error Error.predicate_not_implemented
+ method destroy = List.iter Protocols.Handle.release inputs
+ method enumerate : (Protocols.Handle.t, Concepts.Condition.condition) result = enumerate ()
+ method describe () = Ok (Protocols.Schematics.Relation description)
- method protocol : Protocols.Handle.protocol list =
- Protocols.[ Relation.make self
- ; Enumerable.make self
- ; Schematics.make self ]
- method hash : Concepts.Hash.hash = address
+ method contains (tuple : Concepts.Tuple.t) =
+ let open Utilities.Result in
+ let* cursor = self#enumerate in
+ Fun.protect
+ ~finally:(fun () -> Protocols.Handle.release cursor)
+ (fun () ->
+ let* scan = Protocols.Cursor.require cursor in
+ Protocols.Cursor.exists scan (fun member ->
+ Concepts.Hash.hash_equals (Concepts.Tuple.hash member) (Concepts.Tuple.hash tuple) ) )
+
+ method protocols : Protocols.Handle.protocol list =
+ Protocols.[Relation.make self; Enumerable.make self; Schematics.make self]
end
+
+let instantiate ?(inputs = []) description value enumerate =
+ new ephemeral_relation description value enumerate inputs |> Protocols.Handle.make
diff --git a/lib/kernel/EphemeralRelation.mli b/lib/kernel/EphemeralRelation.mli
deleted file mode 100644
index d082394..0000000
--- a/lib/kernel/EphemeralRelation.mli
+++ /dev/null
@@ -1,36 +0,0 @@
-module type DERIVATION = sig
- type plan
-
- (** the hash of the plan, taken over the branch-local names of its
- inputs rather than over their content addresses. The idea is to
- have the same expression denote one object on every branch and
- at every point in time. *)
- val identity : plan -> Concepts.Hash.hash
-
- val describe :
- plan -> (Protocols.Schematics.relation_description, Concepts.Condition.condition) result
-
- val modes : plan -> (Concepts.Mode.t, Concepts.Condition.condition) result
-
- val generate :
- plan ->
- Protocols.Generative.binding ->
- (Protocols.Handle.t, Concepts.Condition.condition) result
-end
-
-module Make (D : DERIVATION) : sig
- (** unpinned, the identity of the derivation itself; pinned to a
- branch commit, the identity of that derivation against one
- reconstructible state, which is the only form for which equal
- identity implies equal extension. *)
- val identity : ?pinned:Concepts.Hash.hash -> D.plan -> Concepts.Hash.hash
-
- (** edges are the handles the derivation reads, which are released
- when the relation is also. Rejection of a derivation surfaces
- here instead of when a cursor is being drained. *)
- val derive :
- ?pinned:Concepts.Hash.hash ->
- ?edges:Protocols.Handle.t list ->
- D.plan ->
- (Protocols.Handle.t, Concepts.Condition.condition) result
-end
diff --git a/lib/kernel/Multigroup.ml b/lib/kernel/Multigroup.ml
index 602f3a9..88f5948 100644
--- a/lib/kernel/Multigroup.ml
+++ b/lib/kernel/Multigroup.ml
@@ -57,7 +57,7 @@ module Make (S : Abstract.Storage.STORAGE) = struct
[ Addressable.make self;
Prototype.Directory.of_properties
[ ( "relation",
- Prototype.mixture [RMDirectory.make ~storage ~node ~constructor:(R.wrap storage)]
+ Prototype.mixture [RMDirectory.make ~storage ~node ~constructor:(R.load storage)]
) ] ]
method hash = Representation.to_blob multigroup |> Concepts.Hash.hash_of_blob
diff --git a/lib/kernel/SubstantialRelation.ml b/lib/kernel/SubstantialRelation.ml
index 242aedb..844b186 100644
--- a/lib/kernel/SubstantialRelation.ml
+++ b/lib/kernel/SubstantialRelation.ml
@@ -43,12 +43,7 @@ module Make (S : Abstract.Storage.STORAGE) = struct
module TupleSet = Merkle.Interface (S) (TupleKey) (TupleValue)
- type t =
- { schematics: Concepts.Hash.hash;
- predicate: Concepts.Hash.hash option;
- local_constraints: Concepts.Hash.hash option;
- tuples: TupleSet.address;
- indexes: Concepts.Hash.hash option }
+ type t = {schematics: Concepts.Hash.hash; tuples: TupleSet.address}
module rec Representation : (Concepts.Encoding.Record.S with type t = t) =
Concepts.Encoding.Record.Make (Body)
@@ -59,58 +54,26 @@ module Make (S : Abstract.Storage.STORAGE) = struct
let tag = 'R'
let malformed = Error.malformed_relation
- let fields {schematics; predicate; local_constraints; tuples; indexes} =
+ let fields {schematics; tuples} =
let open Concepts.Encoding in
- [ "schema", Value.bencode_of_hash schematics;
- "predicate", Value.bencode_of_option Value.bencode_of_hash predicate;
- "local-constraints", Value.bencode_of_option Value.bencode_of_hash local_constraints;
- "tuples", Value.bencode_of_hash tuples;
- "indexes", Value.bencode_of_option Value.bencode_of_hash indexes ]
+ ["schema", Value.bencode_of_hash schematics; "tuples", Value.bencode_of_hash tuples]
let of_fields fields =
let open Utilities.Result in
let open Concepts.Encoding in
let* schematics = Bencode.field "schema" fields |> fmap Value.hash_of_bencode in
- let* predicate =
- Bencode.field "predicate" fields |> fmap (Value.option_of_bencode Value.hash_of_bencode)
- in
- let* local_constraints =
- Bencode.field "local-constraints" fields
- |> fmap (Value.option_of_bencode Value.hash_of_bencode)
- in
let* tuples = Bencode.field "tuples" fields |> fmap Value.hash_of_bencode in
- let* indexes =
- Bencode.field "indexes" fields |> fmap (Value.option_of_bencode Value.hash_of_bencode)
- in
- Ok {schematics; predicate; local_constraints; tuples; indexes}
+ Ok {schematics; tuples}
end
let encode = Representation.to_blob
let decode = Representation.of_blob
- let schematics {schematics; _} = schematics
- let predicate {predicate; _} = predicate
- let local_constraints {local_constraints; _} = local_constraints
- let tuples {tuples; _} = tuples
- let indexes {indexes; _} = indexes
- let hash relation = Representation.to_blob relation |> Concepts.Hash.hash_of_blob
let tuple_node tx relation =
let open Utilities.Result in
let* tuples = TupleSet.find tx relation.tuples in
Option.to_result ~none:(Error.invalid_tuple_root relation.tuples) tuples
- let empty tx ~schematics ?predicate ?local_constraints ?indexes () =
- let open Utilities.Result in
- let* tuples = TupleSet.empty_under tx in
- Ok {schematics; predicate; local_constraints; tuples; indexes}
-
- let store tx relation = SI.store_blob tx (Representation.to_blob relation)
-
- let contains_tuple tx relation tuple =
- let open Utilities.Result in
- let* node = tuple_node tx relation in
- TupleSet.mem tx (Concepts.Tuple.hash tuple) node
-
let schema_of tx relation =
let open Utilities.Result in
let* data = SI.get_req tx (S.Hash relation.schematics) in
@@ -123,87 +86,52 @@ module Make (S : Abstract.Storage.STORAGE) = struct
|> Utilities.List.sequence
|> Result.map BatMap.String.of_list
- let generate storage relation binding =
+ let enumerate connection relation =
let open Utilities.Result in
- let* tx = S.start_read storage in
+ let* tx = S.start_read connection in
let close () = ignore (S.abort tx) in
let* node = tuple_node tx relation |> Result.map_error (fun c -> close (); c) in
- (* The fold is suspended by [yield], so the tree is walked one node
- and one tuple at a time rather than materialized before the
- first tuple is produced. *)
- let produce ~yield =
- TupleSet.iter tx
- (fun _ tuple -> if Protocols.Generative.satisfies binding tuple then yield tuple)
- node
- in
- Ok (Generator.cursor_of ~finally:close produce)
-
- let enumerate storage relation = generate storage relation Protocols.Generative.nothing
-
- let modes_of description =
- Concepts.Mode.of_list
- [ Concepts.Mode.enumerable Concepts.Cardinality.Finite;
- {Concepts.Mode.bound= Concepts.Mode.attributes_of_map description; affords= Decides} ]
+ Ok
+ (Generator.cursor_of ~finally:close (fun ~yield ->
+ TupleSet.iter tx (fun _ tuple -> yield tuple) node ) )
- class relation storage value description =
+ class substantial_relation connection value description =
object (self)
inherit Lifecycle.null
method to_string = "relation"
- val storage : S.connection = storage
+ val connection : S.connection = connection
val relation : t = value
- val declaration = modes_of description
- method predicate = Ok relation.predicate
- method local_constraints = Ok relation.local_constraints
- (* The protocol takes a tuple, not bytes: encoding is this object's business, and a caller
- that had to produce the exact stored bytes would have to know this encoding to do it. *)
method contains (tuple : Concepts.Tuple.t) =
- SI.with_read storage (fun tx -> contains_tuple tx relation tuple)
+ SI.with_read connection (fun tx ->
+ let open Utilities.Result in
+ let* node = tuple_node tx relation in
+ TupleSet.mem tx (Concepts.Tuple.hash tuple) node )
method describe () = Ok (Protocols.Schematics.Relation description)
-
- (* A substantial relation is finitely enumerable, so it carries [Enumerable] as well as
- [Relation]. A procedural relation would carry only the latter, which is how an evaluator
- discovers it cannot iterate one -- see [Protocols.Enumerable]. The context is accepted and
- unused here: this enumeration reads through its own cursor-lifetime transaction and needs
- no name resolution, but cancellation should eventually be checked between tuples. *)
- method enumerate = enumerate storage relation
- method modes : (Concepts.Mode.t, Concepts.Condition.condition) result = Ok declaration
- method generate binding = generate storage relation binding
+ method enumerate = enumerate connection relation
method protocols : Protocols.Handle.protocol list =
[ Protocols.Relation.make self;
Protocols.Enumerable.make self;
Protocols.Schematics.make self ]
- method hash = hash relation
+ method hash = encode relation |> Concepts.Hash.hash_of_blob
end
- (* A relation never changes its schema, so it is read once here and
- the description and modes are served from it on every request. *)
- let instantiate tx conn relation =
- schema_of tx relation
+ let load connection relation =
+ SI.with_read connection (fun tx -> schema_of tx relation)
|> Result.map (fun description ->
- new relation conn relation description |> Protocols.Handle.make )
-
- let make conn ~schematics ?predicate ?local_constraints ?indexes () =
- let open Utilities.Result in
- SI.with_transaction conn (fun tx ->
- let* relation = empty tx ~schematics ?predicate ?local_constraints ?indexes () in
- let* _ = store tx relation in
- instantiate tx conn relation )
+ new substantial_relation connection relation description |> Protocols.Handle.make )
- let load_value tx addr =
+ let instantiate connection ~schematics =
let open Utilities.Result in
- let* data = SI.get_req tx (S.Hash addr) in
- Representation.of_blob data
-
- let wrap conn relation = SI.with_read conn (fun tx -> instantiate tx conn relation)
- let load tx conn addr = load_value tx addr |> Utilities.Result.fmap (instantiate tx conn)
-
- let assert_tuple tx relation tuple =
- let open Utilities.Result in
- let* node = tuple_node tx relation in
- let* node = TupleSet.insert tx (Concepts.Tuple.hash tuple) tuple node in
- Ok {relation with tuples= TupleSet.hash_of node}
+ let* relation =
+ SI.with_transaction connection (fun tx ->
+ let* tuples = TupleSet.empty_under tx in
+ let relation = {schematics; tuples} in
+ let* _ = SI.store_blob tx (encode relation) in
+ Ok relation )
+ in
+ load connection relation
end
diff --git a/lib/kernel/SubstantialRelation.mli b/lib/kernel/SubstantialRelation.mli
deleted file mode 100644
index 98f1e8f..0000000
--- a/lib/kernel/SubstantialRelation.mli
+++ /dev/null
@@ -1,55 +0,0 @@
-module Make (S : Abstract.Storage.STORAGE) : sig
- type t
-
- val encode : t -> Concepts.Blob.t
- val decode : Concepts.Blob.t -> (t, Concepts.Condition.condition) result
-
- val empty :
- S.transaction ->
- schematics:Concepts.Hash.hash ->
- ?predicate:Concepts.Hash.hash ->
- ?local_constraints:Concepts.Hash.hash ->
- ?indexes:Concepts.Hash.hash ->
- unit ->
- (t, Concepts.Condition.condition) result
-
- val store : S.transaction -> t -> (Concepts.Hash.hash, Concepts.Condition.condition) result
-
- val make :
- S.connection ->
- schematics:Concepts.Hash.hash ->
- ?predicate:Concepts.Hash.hash ->
- ?local_constraints:Concepts.Hash.hash ->
- ?indexes:Concepts.Hash.hash ->
- unit ->
- (Protocols.Handle.t, Concepts.Condition.condition) result
-
- val load_value : S.transaction -> Concepts.Hash.hash -> (t, Concepts.Condition.condition) result
- val wrap : S.connection -> t -> (Protocols.Handle.t, Concepts.Condition.condition) result
-
- val load :
- S.transaction ->
- S.connection ->
- Concepts.Hash.hash ->
- (Protocols.Handle.t, Concepts.Condition.condition) result
-
- val schematics : t -> Concepts.Hash.hash
- val predicate : t -> Concepts.Hash.hash option
- val local_constraints : t -> Concepts.Hash.hash option
- val tuples : t -> Concepts.Hash.hash
- val indexes : t -> Concepts.Hash.hash option
- val hash : t -> Concepts.Hash.hash
-
- val assert_tuple :
- S.transaction -> t -> Concepts.Tuple.t -> (t, Concepts.Condition.condition) result
-
- val contains_tuple :
- S.transaction -> t -> Concepts.Tuple.t -> (bool, Concepts.Condition.condition) result
-
- val schema_of :
- S.transaction ->
- t ->
- (Protocols.Schematics.relation_description, Concepts.Condition.condition) result
-
- val enumerate : S.connection -> t -> (Protocols.Handle.t, Concepts.Condition.condition) result
-end
diff --git a/lib/protocols/Evaluator.ml b/lib/protocols/Evaluator.ml
new file mode 100644
index 0000000..789fb9d
--- /dev/null
+++ b/lib/protocols/Evaluator.ml
@@ -0,0 +1,11 @@
+class type implementation = object
+ method invoke : Handle.t -> (Handle.t, Concepts.Condition.condition) result
+end
+
+type Handle.protocol += Evaluator of implementation
+type t = implementation
+
+let make impl = Evaluator (impl :> implementation)
+let from handle = Handle.into handle (function Evaluator impl -> Some impl | _ -> None)
+let require = Handle.require from
+let invoke i program = Handle.invoke i (fun o -> o#invoke program)
diff --git a/lib/protocols/Evaluator.mli b/lib/protocols/Evaluator.mli
new file mode 100644
index 0000000..3d42b5c
--- /dev/null
+++ b/lib/protocols/Evaluator.mli
@@ -0,0 +1,10 @@
+type t
+
+class type implementation = object
+ method invoke : Handle.t -> (Handle.t, Concepts.Condition.condition) result
+end
+
+val make : #implementation -> Handle.protocol
+val from : Handle.t -> t Handle.interface option
+val require : Handle.t -> (t Handle.interface, Concepts.Condition.condition) result
+val invoke : t Handle.interface -> Handle.t -> (Handle.t, Concepts.Condition.condition) result
diff --git a/lib/protocols/Program.ml b/lib/protocols/Program.ml
deleted file mode 100644
index e50f07d..0000000
--- a/lib/protocols/Program.ml
+++ /dev/null
@@ -1,16 +0,0 @@
-module type PROGRAM = sig
- type t
-end
-
-module Make (P : PROGRAM) = struct
- class type implementation = object
- method invoke : P.t -> (Handle.t, Concepts.Condition.condition) result
- end
-
- type Handle.protocol += Program of implementation
- type t = implementation
-
- let make impl = Program (impl :> implementation)
- let from handle = Handle.into handle (function Program impl -> Some impl | _ -> None)
- let invoke i program = Handle.invoke i (fun o -> o#invoke program)
-end
diff --git a/lib/protocols/Program.mli b/lib/protocols/Program.mli
deleted file mode 100644
index 6cdffd8..0000000
--- a/lib/protocols/Program.mli
+++ /dev/null
@@ -1,15 +0,0 @@
-module type PROGRAM = sig
- type t
-end
-
-module Make (P : PROGRAM) : sig
- type t
-
- class type implementation = object
- method invoke : P.t -> (Handle.t, Concepts.Condition.condition) result
- end
-
- val make : #implementation -> Handle.protocol
- val from : Handle.t -> t Handle.interface option
- val invoke : t Handle.interface -> P.t -> (Handle.t, Concepts.Condition.condition) result
-end
diff --git a/lib/protocols/Relation.ml b/lib/protocols/Relation.ml
index c05337f..3962c9c 100644
--- a/lib/protocols/Relation.ml
+++ b/lib/protocols/Relation.ml
@@ -7,8 +7,6 @@ module Error = struct
end
class type implementation = object
- method predicate : (Concepts.Hash.hash option, Concepts.Condition.condition) result
- method local_constraints : (Concepts.Hash.hash option, Concepts.Condition.condition) result
method contains : Concepts.Tuple.t -> (bool, Concepts.Condition.condition) result
end
@@ -18,6 +16,4 @@ type t = implementation
let make impl = Relation (impl :> implementation)
let from handle = Handle.into handle (function Relation impl -> Some impl | _ -> None)
let require handle = from handle |> Option.to_result ~none:(Error.not_a_relation ())
-let predicate i = Handle.invoke i (fun o -> o#predicate)
-let local_constraints i = Handle.invoke i (fun o -> o#local_constraints)
let contains i tuple = Handle.invoke i (fun o -> o#contains tuple)
diff --git a/lib/protocols/Relation.mli b/lib/protocols/Relation.mli
index b4a11ec..be11cc1 100644
--- a/lib/protocols/Relation.mli
+++ b/lib/protocols/Relation.mli
@@ -1,19 +1,10 @@
type t
class type implementation = object
- method predicate : (Concepts.Hash.hash option, Concepts.Condition.condition) result
- method local_constraints : (Concepts.Hash.hash option, Concepts.Condition.condition) result
method contains : Concepts.Tuple.t -> (bool, Concepts.Condition.condition) result
end
val make : #implementation -> Handle.protocol
val from : Handle.t -> t Handle.interface option
val require : Handle.t -> (t Handle.interface, Concepts.Condition.condition) result
-
-val predicate :
- t Handle.interface -> (Concepts.Hash.hash option, Concepts.Condition.condition) result
-
-val local_constraints :
- t Handle.interface -> (Concepts.Hash.hash option, Concepts.Condition.condition) result
-
val contains : t Handle.interface -> Concepts.Tuple.t -> (bool, Concepts.Condition.condition) result
generated by cgit v1.2.3 (git 2.25.1) at 2026-11-04 05:46:22 +0000