Ogre.S
Monadic interface to the document.
This interface exposes actual setters and getters, that should be used to query data or to store it in a document. The interface is provided by a monad transformer functor, that wraps the Ogre monad into an arbitrary user monad.
Underneath the hood, the Ogre monad is a state monad wrapped into an error monad. The state holds the document, so that it is not needed to pass it along all the functions, and the error monad facilitates error propagation. We do not expose the catch
function from the standard Error monad interface, as we are concerned that it will be abused (we don't see any legitimate usage of this function in the use cases of Ogre that we perceive).
The interface is built around 3 accessors functions for data querying and one mutator for inserting data into a document.
In our model, a document is a set of facts, that describe some abstract entity. We're making a deriviations based on facts. To make a deriviation we need some facts, the particular set of required facts, as well as the modality of the requirement (i.e., how much it is needed), depends on the particular deriviation. For example, we might require
a fact to be present or, if it is optional, we might request
it, finally, we may query for a collection of facts, and apply our deriviation foreach
fact. In other terms, require attribute
mandates that there is one and only one value of the given attribute
, request attribute
asks for zero or one value, and foreach attribute
requires zero or more values of the attribute
.
include Monads.Std.Monad.S
sequence xs
computes a sequence of computations xs
in the left to right order.
module Fn : sig ... end
Various function combinators lifted into the Kleisli category.
module Pair : sig ... end
The pair interface lifted into the monad.
module Triple : sig ... end
The triple interface lifted into a monad.
module Lift : sig ... end
Lifts functions into the monad.
module Exn : sig ... end
Interacting between monads and language exceptions
module Collection : sig ... end
Lifts collection interface into the monad.
module List : Collection.S with type 'a t := 'a list
The Monad.Collection.S interface for lists
module Seq : Collection.S with type 'a t := 'a Core_kernel.Sequence.t
The Monad.Collection.S interface for sequences
include Monads.Std.Monad.Syntax.S with type 'a t := 'a t
val (!!) : 'a -> 'a t
!!x
is return x
!$$$$f
is Lift.quaternary f
include Monads.Std.Monad.Syntax.Let.S with type 'a t := 'a t
include Core_kernel.Monad.S with type 'a t := 'a t
module Monad_infix : sig ... end
val return : 'a -> 'a t
module Let_syntax : sig ... end
module Let : Monads.Std.Monad.Syntax.Let.S with type 'a t := 'a t
Monadic operators, see Monad.Syntax.S for more.
module Syntax : Monads.Std.Monad.Syntax.S with type 'a t := 'a t
Monadic operators, see Monad.Syntax.S for more.
include Monads.Std.Monad.Trans.S with type 'a t := 'a t
require a ~that:p
requires that an attribute a
has one and only one value that satisfies a predicate p
. It is an error, if there are no such values, or if there are more than one value.
request a ~that:p
request no more than one value of an attribute a
, that satisfies a predicate p
. The returned value is wrapped in an option. If there are more than one satisfying value, then it is an error.
foreach query ~f:action
applies an action
for each value of an attributes specified in the query. The query
value is built using a domain specific language embedded into OCaml. This language is very similar to SQL, and has join and where clauses, e.g.,
let better_than_average_students =
foreach Query.(begin
select
~where:(students.(gpa) > float 3.5)
~join:[
[field classid];
[
field teacher ~from:students;
field id ~from:teachers
]]
(from students $ teachers)
end)
~f:(fun s t -> return (s,t))
The type of the query
value encodes the type of the function f
. A well formed query has a type of form (t1 -> t2 -> .. -> tm -> 'a t) -> 'a t
, where t1
till tm
are types of attributes enumerated in the from clause
(in that particular order).
See the Query
module documentation for more information about the query EDSL.
collect query
is the same as foreach query ~f:Fn.id
provide attr v1 v2 ... vm
stores the constituents of an attribute value in the document. An attribute type encodes not only the type of an attribute value, but also a type and the order of the fields. Thus, the attribute
itself captures a format of the attribute representation, the same as format
is used in printf-like functions. In that sense, the provide
function is variadic, where the first argument (the attribute) defines the type and the arity of the function.
val fail : Core_kernel.Error.t -> 'a t
fail error
aborts an inference process with the specified error
.
val failf :
('a, Stdlib.Format.formatter, unit, unit -> 'b t) Core_kernel.format4 ->
'a
failf fmt args... ()
constructs an error based on the specified format fmt
and arguments, terminated by the unit value ()
. Example:
failf "the file type %s is unsupported" name ()
Note: don't forget to terminate a sequence of arguments with an extra unit value. See the corresponding invalid_argf
and failwithf
function for the reason, why this extra argument is needed.
eval property document
makes an inference of a property
based on facts stored in a document
. If all requirements are satisfied and no errors occurred the inferred result.
For example, given the property names_of_best_students
, defined as,
let names_of_best_students =
foreach Query.(select (from students)
~where:(students.(gpa) > float 3.8))
~f:(fun s -> return (Student.name s))
we can evaluate this property, with
eval names_of_best_students
to get a sequence (possibly empty) of all students that have the GPA score greater than 3.8.
exec op doc
executes an operation op
that, presumably, updates the document doc
, returns an updated version.
run op doc
runs an operation op
that does some inference as well as may update the document. This function is a usual part of a generic state monad interface, and is provided for the consistency. Usually, it is a bad idea, or a notion of a bad style to use this function.