Merge provides functions to build custom 3-way merge operators for various user-defined contents.
val ok : 'a -> ('a, conflict) Result.result Lwt.tReturn Ok x.
val conflict :
('a, unit, string, ('b, conflict) Result.result Lwt.t) Pervasives.format4 ->
'aReturn Error (Conflict str).
val bind :
('a, 'b) Result.result Lwt.t ->
('a -> ('c, 'b) Result.result Lwt.t) ->
('c, 'b) Result.result Lwt.tbind r f is the merge result which behaves as of the application of the function f to the return value of r. If r fails, bind r f also fails, with the same conflict.
val map :
('a -> 'c) ->
('a, 'b) Result.result Lwt.t ->
('c, 'b) Result.result Lwt.tmap f m maps the result of a merge. This is the same as bind
m (fun x -> ok (f x)).
type 'a promise = unit -> ('a option, conflict) Result.result Lwt.tAn 'a promise is a function which, when called, will eventually return a value type of 'a. A promise is an optional, lazy and non-blocking value.
val promise : 'a -> 'a promisepromise a is the promise containing a.
map_promise f a is the promise containing f applied to what is promised by a.
bind_promise a f is the promise returned by f applied to what is promised by a.
type 'a f = old:'a promise -> 'a -> 'a -> ('a, conflict) Result.result Lwt.tSignature of a merge function. old is the value of the least-common ancestor.
/----> t1 ----\
----> old |--> result
\----> t2 ----/Call the merge functions in sequence. Stop as soon as one is not returning a conflict.
Use the merge function defined in another domain. If the converting functions raise any exception the merge is a conflict.
Same as biject but with blocking domain converting functions.
default t is the default merge function for values of type t. This is a simple merge function which supports changes in one branch at a time:
t1=old then the result of the merge is OK t2;t2=old then return OK t1;Conflict.idempotent t is the default merge function for values of type t using idempotent operations. It follows the same rules as the default merge function but also adds:
t1=t2 then the result of the merge is OK t1.val unit : unit tunit is the default merge function for unit values.
val bool : bool tbool is the default merge function for booleans.
val char : char tchar is the default merge function for characters.
val int32 : int32 tint32 is the default merge function for 32-bits integers.
val int64 : int64 tint64 the default merge function for 64-bit integers.
val float : float tfloat is the default merge function for floating point numbers.
val string : string tThe default string merge function. Do not do anything clever, just compare the strings using the default merge function.
Lift a merge function to optional values of the same type. If all the provided values are inhabited, then call the provided merge function, otherwise use the same behavior as default.
The type for counter values. It is expected that the only valid operations on counters are increment and decrement. The following merge functions ensure that the counter semantics are preserved: i.e. it ensures that the number of increments and decrements is preserved.
We consider the only valid operations for maps and association lists to be:
We thus assume that no operation on maps is modifying the key names. So the following merge functions ensures that (i) new bindings are preserved (ii) removed bindings stay removed and (iii) modified bindings are merged using the merge function of values.
Note: We only consider sets of bindings, instead of multisets. Application developers should take care of concurrent addition and removal of similar bindings themselves, by using the appropriate multi-sets.
Lift the merge functions to association lists.
Lift the merge functions to maps.
val result_t : 'a Type.t -> ('a, conflict) Result.result Type.tresult_t is the value type for merge results.