22 files changed, 136 insertions, 573 deletions
diff --git a/lib/concepts/Blob.ml b/lib/concepts/Blob.ml
new file mode 100644
index 0000000..c5d7d5c
--- /dev/null
+++ b/lib/concepts/Blob.ml
@@ -0,0 +1,17 @@
+(* @needs Value *)
+
+(* The intent of this being an abstract type is to allow for switching
+   the implementation to one backed by a C array later on, which would
+   let us avoid copying when passing it through FFI boundaries. *)
+type t = bytes
+
+let blob_of_bytes (b : bytes) = b
+let bytes_of_blob (b : t) = b
+let create = Bytes.create
+let set = Bytes.set
+let set_int64_be = Bytes.set_int64_be
+let blit_string = Bytes.blit_string
+let length = Bytes.length
+let get = Bytes.get
+let sub_string = Bytes.sub_string
+let get_int64_be = Bytes.get_int64_be
diff --git a/lib/concepts/Blob.mli b/lib/concepts/Blob.mli
new file mode 100644
index 0000000..b7c5da3
--- /dev/null
+++ b/lib/concepts/Blob.mli
@@ -0,0 +1,26 @@
+(** an abstract representation of an encoded value *)
+type t
+
+(* TODO: see the comments on Backend.Storage.LMDB *)
+
+(** create a blob from the data represented by bytes *)
+val blob_of_bytes : bytes -> t
+
+(** return a bytes containing the data underlying a blob *)
+val bytes_of_blob : t -> bytes
+
+val create : int -> t
+
+val set : t -> int -> char -> unit
+
+val set_int64_be : t -> int -> int64 -> unit
+
+val blit_string : string -> int -> t -> int -> int -> unit
+
+val length : t -> int
+
+val get : t -> int -> char
+
+val sub_string : t -> int -> int -> string
+
+val get_int64_be : t -> int -> int64
diff --git a/lib/concepts/Branch.ml b/lib/concepts/Branch.ml
deleted file mode 100644
index cd4213b..0000000
--- a/lib/concepts/Branch.ml
+++ /dev/null
@@ -1,49 +0,0 @@
-type address = Hash.hash
-
-type t =
-  { name: string;
-    target: address }
-
-module Field = struct
-  let name = "name"
-  let target = "target"
-end
-
-module Error = struct
-  open Condition
-
-  let malformed_branch () =
-    condition "branch-malformed" "A branch representation did not conform to what was expected"
-      empty
-
-  let malformed_hash length =
-    condition "branch-malformed-hash" "A branch target root was not a valid hash"
-      ("length" |=| Value.Integer length)
-end
-
-let make ~name ~target = {name; target}
-
-let name branch = branch.name
-let target branch = branch.target
-
-module Body = struct
-  type nonrec t = t
-
-  let tag = 'b'
-  let malformed = Error.malformed_branch
-
-  let equal left right =
-    left.name = right.name && Hash.hash_equals left.target right.target
-
-  let fields branch =
-    [ Field.name, Object.Field.string branch.name;
-      Field.target, Object.Field.address branch.target ]
-
-  let of_fields data =
-    let open Utilities.Result in
-    let* name = Object.Field.require_string Field.name data in
-    let* target = Object.Field.require_address ~malformed:Error.malformed_hash Field.target data in
-    Ok {name; target}
-end
-
-include (Object.Codec.Make (Body) : Object.S with type t := t)
diff --git a/lib/concepts/Branch.mli b/lib/concepts/Branch.mli
deleted file mode 100644
index 0e7e9f9..0000000
--- a/lib/concepts/Branch.mli
+++ /dev/null
@@ -1,9 +0,0 @@
-type t
-type address = Hash.hash
-
-include Object.S with type t := t
-
-val make : name:string -> target:address -> t
-
-val name : t -> string
-val target : t -> address
diff --git a/lib/concepts/BranchState.ml b/lib/concepts/BranchState.ml
deleted file mode 100644
index e8c6636..0000000
--- a/lib/concepts/BranchState.ml
+++ /dev/null
@@ -1,87 +0,0 @@
-type address = Hash.hash
-
-(* A branch state records durable branch data only. The runtime registry paths
-   mounted around it, such as /system/branches/master, are derived at
-   initialization and should not be persisted as part of [current]. *)
-type t = {current: address; history: address; tip: address option}
-
-module Field = struct
-  let current = "current"
-  let history = "history"
-  let tip = "tip"
-end
-
-module Error = struct
-  open Condition
-
-  let malformed_branch_state () =
-    condition "branch-state-malformed"
-      "A branch state representation did not conform to what was expected" empty
-
-  let malformed_hash length =
-    condition "branch-state-malformed-hash" "A branch state address was not a valid hash"
-      ("length" |=| Value.Integer length)
-end
-
-let make ~current ~history ~tip = {current; history; tip}
-let current branch_state = branch_state.current
-let history branch_state = branch_state.history
-let tip branch_state = branch_state.tip
-let address_bencode address = Object.Field.address address
-
-let address_option_bencode = function
-  | None -> Codec.Bencode.List []
-  | Some address -> Codec.Bencode.List [address_bencode address]
-
-let require_address_bencode = function
-  | Codec.Bencode.String raw ->
-      if String.length raw = Hash.size then Ok (Hash.of_raw_string raw)
-      else Error (Error.malformed_hash (String.length raw))
-  | _ -> Error (Error.malformed_branch_state ())
-
-let require_address_option key data =
-  let open Utilities.Result in
-  let* value = Codec.Bencode.field key data in
-  let* entries = Codec.Bencode.as_list value in
-  match entries with
-  | [] -> Ok None
-  | [value] ->
-      let* address = require_address_bencode value in
-      Ok (Some address)
-  | _ -> Error (Error.malformed_branch_state ())
-
-let equal_address_option left right =
-  match left, right with
-  | None, None -> true
-  | Some left, Some right -> Hash.hash_equals left right
-  | _ -> false
-
-module Body = struct
-  type nonrec t = t
-
-  let tag = 's'
-  let malformed = Error.malformed_branch_state
-
-  let equal left right =
-    Hash.hash_equals left.current right.current
-    && Hash.hash_equals left.history right.history
-    && equal_address_option left.tip right.tip
-
-  let fields branch_state =
-    [ Field.current, address_bencode branch_state.current;
-      Field.history, address_bencode branch_state.history;
-      Field.tip, address_option_bencode branch_state.tip ]
-
-  let of_fields data =
-    let open Utilities.Result in
-    let* current =
-      Object.Field.require_address ~malformed:Error.malformed_hash Field.current data
-    in
-    let* history =
-      Object.Field.require_address ~malformed:Error.malformed_hash Field.history data
-    in
-    let* tip = require_address_option Field.tip data in
-    Ok {current; history; tip}
-end
-
-include (Object.Codec.Make (Body) : Object.S with type t := t)
diff --git a/lib/concepts/BranchState.mli b/lib/concepts/BranchState.mli
deleted file mode 100644
index 45792cc..0000000
--- a/lib/concepts/BranchState.mli
+++ /dev/null
@@ -1,17 +0,0 @@
-type t
-type address = Hash.hash
-
-include Object.S with type t := t
-
-(** Durable state of one branch head.
-
-    [current] is the branch-visible catalog root, not the runtime namespace
-    rooted at [/system]. Runtime scaffolding is rebuilt during initialization.
-    [history] is the ordered commit-stream tree root. [tip] is absent until the
-    first real commit, so initialization does not create a synthetic commit just
-    to make the branch non-empty. *)
-val make : current:address -> history:address -> tip:address option -> t
-
-val current : t -> address
-val history : t -> address
-val tip : t -> address option
diff --git a/lib/concepts/Codec.ml b/lib/concepts/Encoding.ml
index 758d718..121e98d 100644
--- a/lib/concepts/Codec.ml
+++ b/lib/concepts/Encoding.ml
@@ -1,3 +1,33 @@
+(* A blob is a one-byte constructor tag followed by its payload. The
+   tag makes the encoding self-describing so [value_of_blob] can
+   recover the constructor:
+   - String  ['\000'] ++ raw utf-8 bytes
+   - Integer ['\001'] ++ 8-byte big-endian int64 *)
+let tag_string = '\000'
+let tag_integer = '\001'
+
+let blob_of_value = function
+  | Value.String s ->
+      let b = Blob.create (1 + String.length s) in
+      Blob.set b 0 tag_string;
+      Blob.blit_string s 0 b 1 (String.length s);
+      b
+  | Value.Integer n ->
+      let b = Blob.create 9 in
+      Blob.set b 0 tag_integer;
+      Blob.set_int64_be b 1 (Int64.of_int n);
+      b
+
+let value_of_blob (b : Blob.t) =
+  let n = Blob.length b in
+  if n = 0 then invalid_arg "value_of_blob: empty blob";
+  match Blob.get b 0 with
+  | c when c = tag_string -> Value.String (Blob.sub_string b 1 (n - 1))
+  | c when c = tag_integer ->
+      if n <> 9 then invalid_arg "value_of_blob: malformed integer payload";
+      Value.Integer (Int64.to_int (Blob.get_int64_be b 1))
+  | c -> invalid_arg (Printf.sprintf "value_of_blob: unknown tag %C" c)
+
  module Error = struct
   open Condition
 
@@ -162,8 +192,8 @@ module Bencode = struct
     if !pos <> n then Error Error.trailing_bytes else
       Ok value
 
-  let to_blob x = to_bytes x |> Representation.blob_of_bytes
-  let of_blob b = Representation.bytes_of_blob b |> of_bytes
+  let to_blob x = to_bytes x |> Blob.blob_of_bytes
+  let of_blob b = Blob.bytes_of_blob b |> of_bytes
 
   let with_tag t = function
     | Tagged (t', v) ->
@@ -180,3 +210,62 @@ module Bencode = struct
       | None -> Error (Error.missing_field key) )
     | _ -> Error (Error.type_mismatch ~expected:"dict")
 end
+
+module Field = struct
+  let string value = Bencode.String value
+  let address address = Bencode.String (Hash.to_raw_string address)
+
+  let require_string key data =
+    Bencode.field key data |> Utilities.Result.fmap Bencode.as_string
+
+  let require_address ~malformed key data =
+    let open Utilities.Result in
+    let* raw = require_string key data in
+    if String.length raw = Hash.size then Ok (Hash.of_raw_string raw)
+    else Error (malformed (String.length raw))
+end
+
+module Record = struct
+  module type S = sig
+    type t
+
+    val equal : t -> t -> bool
+
+    val to_bencode : t -> Bencode.t
+    val of_bencode : Bencode.t -> (t, Condition.condition) result
+
+    val to_blob : t -> Blob.t
+    val of_blob : Blob.t -> (t, Condition.condition) result
+
+    val to_bytes : t -> bytes
+    val of_bytes : bytes -> (t, Condition.condition) result
+  end
+
+  module type BODY = sig
+    type t
+
+    val tag : char
+    val malformed : unit -> Condition.condition
+    val equal : t -> t -> bool
+    val fields : t -> (string * Bencode.t) list
+    val of_fields : Bencode.t -> (t, Condition.condition) result
+  end
+
+  module Make (B : BODY) = struct
+    type t = B.t
+
+    let equal = B.equal
+    let to_bencode object_ = Bencode.Tagged (B.tag, Bencode.Dict (B.fields object_))
+
+    let of_bencode = function
+      | Bencode.Tagged (tag, (Bencode.Dict _ as data)) when Char.equal tag B.tag ->
+         B.of_fields data
+      | _ -> Error (B.malformed ())
+
+    let to_blob object_ = to_bencode object_ |> Bencode.to_blob
+    let of_blob blob = Bencode.of_blob blob |> Utilities.Result.fmap of_bencode
+
+    let to_bytes object_ = to_blob object_ |> Blob.bytes_of_blob
+    let of_bytes bytes = Bencode.of_bytes bytes |> Utilities.Result.fmap of_bencode
+  end
+end
diff --git a/lib/concepts/Hash.ml b/lib/concepts/Hash.ml
index 62c7789..ae0a178 100644
--- a/lib/concepts/Hash.ml
+++ b/lib/concepts/Hash.ml
@@ -7,12 +7,9 @@ let size = 256/8
 let compare h1 h2 = Digestif.SHA256.unsafe_compare h1 h2
                     |> Ordering.of_int
 
-let hash_of_value (v : Value.value) =
-  Representation.(blob_of_value v |> bytes_of_blob) |> Digestif.SHA256.digest_bytes
-
 let hash_of_bytes bytes = Digestif.SHA256.digest_bytes bytes
 
-let hash_of_blob blob = Representation.bytes_of_blob blob |> Digestif.SHA256.digest_bytes
+let hash_of_blob blob = Blob.bytes_of_blob blob |> Digestif.SHA256.digest_bytes
 
 let to_raw_string hash = Digestif.SHA256.to_raw_string hash
 
diff --git a/lib/concepts/Hash.mli b/lib/concepts/Hash.mli
index f40d9aa..b3ae2dc 100644
--- a/lib/concepts/Hash.mli
+++ b/lib/concepts/Hash.mli
@@ -4,14 +4,11 @@ type hash
 (** the size of a hash, in bytes *)
 val size : int
 
-(** given a value, compute it's hash *)
-val hash_of_value : Value.value -> hash
-
 (** given a bag of bytes, compute it's hash *)
 val hash_of_bytes : bytes -> hash
 
 (** given a blob, compute it's hash *)
-val hash_of_blob : Representation.blob -> hash
+val hash_of_blob : Blob.t -> hash
 
 (** given a hash, return a representation of it as a string (/not/ the usual hex representation!) *)
 val to_raw_string : hash -> string
diff --git a/lib/concepts/Multigroup.ml b/lib/concepts/Multigroup.ml
deleted file mode 100644
index 863cd26..0000000
--- a/lib/concepts/Multigroup.ml
+++ /dev/null
@@ -1,51 +0,0 @@
-type address = Hash.hash
-
-type t =
-  { name: string;
-    relations: address }
-
-module Field = struct
-  let name = "name"
-  let relations = "relations"
-end
-
-module Error = struct
-  open Condition
-
-  let malformed_multigroup () =
-    condition "multigroup-malformed"
-      "A multigroup representation did not conform to what was expected" empty
-
-  let malformed_hash length =
-    condition "multigroup-malformed-hash" "A multigroup relation root was not a valid hash"
-      ("length" |=| Value.Integer length)
-end
-
-let make ~name ~relations = {name; relations}
-
-let name multigroup = multigroup.name
-let relations multigroup = multigroup.relations
-
-module Body = struct
-  type nonrec t = t
-
-  let tag = 'm'
-  let malformed = Error.malformed_multigroup
-
-  let equal left right =
-    left.name = right.name && Hash.hash_equals left.relations right.relations
-
-  let fields multigroup =
-    [ Field.name, Object.Field.string multigroup.name;
-      Field.relations, Object.Field.address multigroup.relations ]
-
-  let of_fields data =
-    let open Utilities.Result in
-    let* name = Object.Field.require_string Field.name data in
-    let* relations =
-      Object.Field.require_address ~malformed:Error.malformed_hash Field.relations data
-    in
-    Ok {name; relations}
-end
-
-include (Object.Codec.Make (Body) : Object.S with type t := t)
diff --git a/lib/concepts/Multigroup.mli b/lib/concepts/Multigroup.mli
deleted file mode 100644
index 1a76dce..0000000
--- a/lib/concepts/Multigroup.mli
+++ /dev/null
@@ -1,9 +0,0 @@
-type t
-type address = Hash.hash
-
-include Object.S with type t := t
-
-val make : name:string -> relations:address -> t
-
-val name : t -> string
-val relations : t -> address
diff --git a/lib/concepts/Object.ml b/lib/concepts/Object.ml
deleted file mode 100644
index 22fb14a..0000000
--- a/lib/concepts/Object.ml
+++ /dev/null
@@ -1,64 +0,0 @@
-type bencode = Codec.Bencode.t
-
-module Bencode = Codec.Bencode
-
-module type S = sig
-  type t
-
-  val equal : t -> t -> bool
-
-  val to_bencode : t -> bencode
-  val of_bencode : bencode -> (t, Condition.condition) result
-
-  val to_blob : t -> Representation.blob
-  val of_blob : Representation.blob -> (t, Condition.condition) result
-
-  val to_bytes : t -> bytes
-  val of_bytes : bytes -> (t, Condition.condition) result
-end
-
-module type OBJECT = S
-
-module Field = struct
-  let string value = Bencode.String value
-  let address address = Bencode.String (Hash.to_raw_string address)
-
-  let require_string key data =
-    Codec.Bencode.field key data |> Utilities.Result.fmap Codec.Bencode.as_string
-
-  let require_address ~malformed key data =
-    let open Utilities.Result in
-    let* raw = require_string key data in
-    if String.length raw = Hash.size then Ok (Hash.of_raw_string raw)
-    else Error (malformed (String.length raw))
-end
-
-module Codec = struct
-  module type BODY = sig
-    type t
-
-    val tag : char
-    val malformed : unit -> Condition.condition
-    val equal : t -> t -> bool
-    val fields : t -> (string * bencode) list
-    val of_fields : bencode -> (t, Condition.condition) result
-  end
-
-  module Make (B : BODY) = struct
-    type t = B.t
-
-    let equal = B.equal
-    let to_bencode object_ = Bencode.Tagged (B.tag, Bencode.Dict (B.fields object_))
-
-    let of_bencode = function
-      | Bencode.Tagged (tag, (Bencode.Dict _ as data)) when Char.equal tag B.tag ->
-          B.of_fields data
-      | _ -> Error (B.malformed ())
-
-    let to_blob object_ = to_bencode object_ |> Bencode.to_blob
-    let of_blob blob = Bencode.of_blob blob |> Utilities.Result.fmap of_bencode
-
-    let to_bytes object_ = to_blob object_ |> Representation.bytes_of_blob
-    let of_bytes bytes = Bencode.of_bytes bytes |> Utilities.Result.fmap of_bencode
-  end
-end
diff --git a/lib/concepts/Object.mli b/lib/concepts/Object.mli
deleted file mode 100644
index e132673..0000000
--- a/lib/concepts/Object.mli
+++ /dev/null
@@ -1,45 +0,0 @@
-type bencode = Codec.Bencode.t
-
-module type S = sig
-  type t
-
-  val equal : t -> t -> bool
-
-  val to_bencode : t -> bencode
-  val of_bencode : bencode -> (t, Condition.condition) result
-
-  val to_blob : t -> Representation.blob
-  val of_blob : Representation.blob -> (t, Condition.condition) result
-
-  val to_bytes : t -> bytes
-  val of_bytes : bytes -> (t, Condition.condition) result
-end
-
-module type OBJECT = S
-
-module Field : sig
-  val string : string -> bencode
-  val address : Hash.hash -> bencode
-
-  val require_string : string -> bencode -> (string, Condition.condition) result
-
-  val require_address :
-    malformed:(int -> Condition.condition) ->
-    string ->
-    bencode ->
-    (Hash.hash, Condition.condition) result
-end
-
-module Codec : sig
-  module type BODY = sig
-    type t
-
-    val tag : char
-    val malformed : unit -> Condition.condition
-    val equal : t -> t -> bool
-    val fields : t -> (string * bencode) list
-    val of_fields : bencode -> (t, Condition.condition) result
-  end
-
-  module Make (B : BODY) : S with type t = B.t
-end
diff --git a/lib/concepts/Ordering.mli b/lib/concepts/Ordering.mli
deleted file mode 100644
index ab8a3f4..0000000
--- a/lib/concepts/Ordering.mli
+++ /dev/null
@@ -1,3 +0,0 @@
-type ordering = Equal | Smaller | Greater
-
-val of_int : int -> ordering
diff --git a/lib/concepts/Path.ml b/lib/concepts/Path.ml
deleted file mode 100644
index c751301..0000000
--- a/lib/concepts/Path.ml
+++ /dev/null
@@ -1,16 +0,0 @@
-type t = string BatFingerTree.t
-
-let empty : t = BatFingerTree.empty
-let of_list (components : string list) : t = BatFingerTree.of_list components
-let to_list (path : t) : string list = BatFingerTree.to_list path
-let snoc (path : t) (component : string) : t = BatFingerTree.snoc path component
-let to_string (path : t) : string = String.concat "/" (to_list path)
-
-let is_prefix ~(prefix : t) (path : t) : bool =
-  let rec walk prefix path =
-    match prefix, path with
-    | [], _ -> true
-    | p :: prefix, x :: path -> p = x && walk prefix path
-    | _ :: _, [] -> false
-  in
-  walk (to_list prefix) (to_list path)
diff --git a/lib/concepts/Path.mli b/lib/concepts/Path.mli
deleted file mode 100644
index bec4221..0000000
--- a/lib/concepts/Path.mli
+++ /dev/null
@@ -1,8 +0,0 @@
-type t = string BatFingerTree.t
-
-val empty : t
-val of_list : string list -> t
-val to_list : t -> string list
-val snoc : t -> string -> t
-val to_string : t -> string
-val is_prefix : prefix:t -> t -> bool
diff --git a/lib/concepts/Relation.ml b/lib/concepts/Relation.ml
deleted file mode 100644
index a4fb341..0000000
--- a/lib/concepts/Relation.ml
+++ /dev/null
@@ -1,81 +0,0 @@
-type address = Hash.hash
-type schema = string BatMap.String.t
-
-type t =
-  { name: string;
-    tuples: address;
-    schema: schema }
-
-module Field = struct
-  let name = "name"
-  let tuples = "tuples"
-  let schema = "schema"
-end
-
-module Error = struct
-  open Condition
-
-  let malformed_relation () =
-    condition "relation-malformed" "A relation representation did not conform to what was expected"
-      empty
-
-  let malformed_hash length =
-    condition "relation-malformed-hash" "A relation tuple root was not a valid hash"
-      ("length" |=| Value.Integer length)
-end
-
-let make ~name ~tuples ~schema = {name; tuples; schema}
-
-let name relation = relation.name
-let tuples relation = relation.tuples
-let schema relation = relation.schema
-
-let schema_empty = BatMap.String.empty
-
-let schema_of_list fields =
-  List.fold_left (fun acc (name, domain) -> BatMap.String.add name domain acc) schema_empty
-    fields
-
-let schema_to_list schema = BatMap.String.bindings schema
-
-let schema_to_bencode schema =
-  Codec.Bencode.Dict
-    (schema_to_list schema
-    |> List.map (fun (name, domain) -> name, Codec.Bencode.String domain) )
-
-let schema_of_bencode value =
-  let open Utilities.Result in
-  let* fields = Codec.Bencode.as_dict value in
-  fields
-  |> List.map (fun (name, domain) ->
-         let* domain = Codec.Bencode.as_string domain in
-         Ok (name, domain) )
-  |> sequence
-  |> Result.map schema_of_list
-
-module Body = struct
-  type nonrec t = t
-
-  let tag = 'r'
-  let malformed = Error.malformed_relation
-
-  let equal left right =
-    left.name = right.name
-    && Hash.hash_equals left.tuples right.tuples
-    && BatMap.String.equal String.equal left.schema right.schema
-
-  let fields relation =
-    [ Field.name, Object.Field.string relation.name;
-      Field.schema, schema_to_bencode relation.schema;
-      Field.tuples, Object.Field.address relation.tuples ]
-
-  let of_fields data =
-    let open Utilities.Result in
-    let* name = Object.Field.require_string Field.name data in
-    let* tuples = Object.Field.require_address ~malformed:Error.malformed_hash Field.tuples data in
-    let* schema_data = Codec.Bencode.field Field.schema data in
-    let* schema = schema_of_bencode schema_data in
-    Ok {name; tuples; schema}
-end
-
-include (Object.Codec.Make (Body) : Object.S with type t := t)
diff --git a/lib/concepts/Relation.mli b/lib/concepts/Relation.mli
deleted file mode 100644
index 5319a3d..0000000
--- a/lib/concepts/Relation.mli
+++ /dev/null
@@ -1,15 +0,0 @@
-type t
-type address = Hash.hash
-type schema
-
-include Object.S with type t := t
-
-val make : name:string -> tuples:address -> schema:schema -> t
-
-val name : t -> string
-val tuples : t -> address
-val schema : t -> schema
-
-val schema_empty : schema
-val schema_of_list : (string * string) list -> schema
-val schema_to_list : schema -> (string * string) list
diff --git a/lib/concepts/Representation.ml b/lib/concepts/Representation.ml
deleted file mode 100644
index 12c3624..0000000
--- a/lib/concepts/Representation.ml
+++ /dev/null
@@ -1,36 +0,0 @@
-(* @needs Value *)
-
-type blob = bytes
-
-let blob_of_bytes (b : bytes) = b
-let bytes_of_blob (b : blob) = b
-
-(* A blob is a one-byte constructor tag followed by its payload. The
-   tag makes the encoding self-describing so [value_of_blob] can
-   recover the constructor:
-   - String  ['\000'] ++ raw utf-8 bytes
-   - Integer ['\001'] ++ 8-byte big-endian int64 *)
-let tag_string = '\000'
-let tag_integer = '\001'
-
-let blob_of_value = function
-  | Value.String s ->
-      let b = Bytes.create (1 + String.length s) in
-      Bytes.set b 0 tag_string;
-      Bytes.blit_string s 0 b 1 (String.length s);
-      b
-  | Value.Integer n ->
-      let b = Bytes.create 9 in
-      Bytes.set b 0 tag_integer;
-      Bytes.set_int64_be b 1 (Int64.of_int n);
-      b
-
-let value_of_blob (b : blob) =
-  let n = Bytes.length b in
-  if n = 0 then invalid_arg "value_of_blob: empty blob";
-  match Bytes.get b 0 with
-  | c when c = tag_string -> Value.String (Bytes.sub_string b 1 (n - 1))
-  | c when c = tag_integer ->
-      if n <> 9 then invalid_arg "value_of_blob: malformed integer payload";
-      Value.Integer (Int64.to_int (Bytes.get_int64_be b 1))
-  | c -> invalid_arg (Printf.sprintf "value_of_blob: unknown tag %C" c)
diff --git a/lib/concepts/Representation.mli b/lib/concepts/Representation.mli
deleted file mode 100644
index 21c43a4..0000000
--- a/lib/concepts/Representation.mli
+++ /dev/null
@@ -1,16 +0,0 @@
-(** an abstract representation of an encoded value *)
-type blob
-
-(** encode a blob into a value *)
-val blob_of_value : Value.value -> blob
-
-(** decode a value from a blob *)
-val value_of_blob : blob -> Value.value
-
-(* TODO: see the comments on Backend.Storage.LMDB *)
-
-(** create a blob from the data represented by bytes *)
-val blob_of_bytes : bytes -> blob
-
-(** return a bytes containing the data underlying a blob *)
-val bytes_of_blob : blob -> bytes
diff --git a/lib/concepts/Tuple.ml b/lib/concepts/Tuple.ml
deleted file mode 100644
index 8fac426..0000000
--- a/lib/concepts/Tuple.ml
+++ /dev/null
@@ -1,48 +0,0 @@
-(* @needs Value *)
-
-module AttributeMap = BatMap.String
-
-(** A tuple: a finite map from attribute name to attribute. *)
-type t = Value.value AttributeMap.t
-
-(** [empty] The tuple with no attributes. *)
-let empty : t = AttributeMap.empty
-
-(** [access name t] Looks up the attribute bound to [name] in [t].
-    @param name attribute name to look up.
-    @param t tuple to search.
-    @return the attribute, or [None] when [name] is unbound. *)
-let access (name : string) (t : t) : Value.value option = AttributeMap.find_opt name t
-
-(** [merge left right] Unions two tuples. Shared attributes take the
-    [left] value; one-sided attributes are kept. Precondition: shared
-    attributes agree (the natural-join matcher guarantees this), so the
-    [left] bias is never observable.
-    @param left first tuple.
-    @param right second tuple.
-    @return the merged tuple. *)
-let merge (left : t) (right : t) : t =
-  let merger _ (left : Value.value option) (right : Value.value option) : Value.value option =
-    match left, right with (Some _ as v), _ | None, (Some _ as v) -> v | None, None -> None
-  in
-  AttributeMap.merge merger left right
-
-(** [project keep t] Keeps only the attributes of [t] whose names are
-    in [keep].
-    @param keep set of attribute names to retain.
-    @param t tuple to project.
-    @return the projected tuple. *)
-let project (keep : BatSet.String.t) (t : t) : t =
-  AttributeMap.filter (fun name _ -> BatSet.String.mem name keep) t
-
-(** [rename mapping t] Renames the attributes of [t] through
-    [mapping]; names absent from [mapping] are left unchanged.
-    @param mapping map from old name to new name.
-    @param t tuple to rename.
-    @return the renamed tuple. *)
-let rename (mapping : string BatMap.String.t) (t : t) : t =
-  AttributeMap.fold
-    (fun name attr acc ->
-      let name = BatMap.String.find_default name name mapping in
-      AttributeMap.add name attr acc )
-    t AttributeMap.empty
diff --git a/lib/concepts/Tuple.mli b/lib/concepts/Tuple.mli
deleted file mode 100644
index 07f7a24..0000000
--- a/lib/concepts/Tuple.mli
+++ /dev/null
@@ -1,9 +0,0 @@
-module AttributeMap = BatMap.String
-
-type t = Value.value AttributeMap.t
-
-val empty : t
-val access : string -> t -> Value.value option
-val merge : t -> t -> t
-val project : BatSet.String.t -> t -> t
-val rename : string BatMap.String.t -> t -> t