A value is a concrete representation of knowledge. It is a snapshot of all properties associated with some object, i.e., an ordered tuple of slots. The value has no identity and that differs it from the object, as the value is essentially a property of an object - not an object itself.
From another perspective, a value is an extensible record, with fields reified into first-class slots, the record type into the
cls values, and an additional constraint that all field types must be an instance of the domain type class (i.e., have a default and an ordering).
Each value has a class. The class value itself is indexed with the class and sort indices. The first index denotes the set of properties that could be associated with the value. The second index further partitions values of that class into subsets, to so that domain specific relations between values could be expressed explicitly with the host language type system.
The value sort is an arbitrary value, which can also be used to store additional static information about the value, i.e., the information that is common to all instances of the sort.
Total ordering and age
In addition to be partially ordered by their information content, values are also totally ordered, so that they could be organized into finite sets and maps.
The total order is induced from the information order, so that if a value
x is ordered before
y in the information order, then it will be also ordered before
y in the total order. And if
y have the same information content, then they are considered equal. Values with non-comparable information content are ordered by their time-stamp.
Every time a new value created it is assigned a time-stamp. A new value is created by all functions that has
'a value return type, except the
refine function. Each time-stamp is unique and no two values could have the same time-stamps unless they are physically the same, or are de-serializations of the same value, or are refinements of the same value. In other words, values with equal time-stamps are guaranteed to bear the same information.
Time-stamp values correlate with the order of evaluation. A value that was evaluated more recently will have a higher time-stamp. Therefore time-stamps define an age of a value. A value which has a smaller time-stamp is younger than a value that has a larger time-stamp.
type 'a t = 'a value
include Core_kernel.Type_equal.Injective with type 'a t := 'a t
val strip : ('a t, 'b t) Base.Type_equal.equal -> ('a, 'b) Base.Type_equal.equal
empty cls the empty value of class
The empty value has the least information content, i.e., all slots are empty.
val order : 'a value -> 'a value -> Order.partial
order x y orders
y by their information content.
val join : 'a value -> 'a value -> ('a value, conflict) Core_kernel.result
join x y joins pairwise all slots of
Each slot of
y are joined using the
Domain.join function. The result is either a pairwise join or a conflict if any of the joins ended up with a conflict.
val merge : ?on_conflict:[ `drop_old | `drop_new | `drop_right | `drop_left ] -> 'a value -> 'a value -> 'a value
merge x y joins
y and resolves conflicts.
Performs a pairwise join of
y and in case if any of the joins yields a conflict uses the provided strategy to resolve it.
put p v x sets a value of the property
refine v s refines the sort of
Since, this function doesn't change the information stored in the value, the time-stamp of the returned value is the same, therefore
v = refine v s.
module type S = sig ... end
val derive : ('a, 's) cls -> (module S with type comparator_witness = ('a, 's) cls ord and type t = ('a, 's) cls t)
derive cls derives the implementation of the
val pp : Format.formatter -> 'a value -> unit
pp ppf v outputs
v to the formatter
Prints all slots of the value
val pp_slots : string list -> Format.formatter -> 'a value -> unit
pp_slots slots ppf v prints the specified set of slots.
Prints only slots that has a name in