Module Core_kernel.Blang
Boolean expressions.
Usage
For example, imagine writing a config file for an application that filters a stream of integers. Your goal is to keep only those integers that are multiples of either -3 or 5. Using Blang
for this task, the code might look like:
module Property = struct
type t =
| Multiple_of of int
| Positive
| Negative
[@@deriving sexp]
let eval t num =
match t with
| Multiple_of n -> num % n = 0
| Positive -> num > 0
| Negative -> num < 0
end
type config = {
keep : Property.t Blang.t;
} [@@deriving sexp]
let config = {
keep =
Blang.t_of_sexp
Property.t_of_sexp
(Sexp.of_string
"(or (and negative (multiple_of 3)) (and positive (multiple_of 5)))";
}
let keep config num : bool =
Blang.eval config.keep (fun p -> Property.eval p num)
Note how positive
and negative
and multiple_of
become operators in a small, newly-defined boolean expression language that allows you to write statements like (and negative (multiple_of 3))
.
Blang sexp syntax
The blang sexp syntax is almost exactly the derived one, except that:
1. Base properties are not marked explicitly. Thus, if your base property type has elements FOO, BAR, etc., then you could write the following Blang s-expressions:
FOO (and FOO BAR) (if FOO BAR BAZ)
and so on. Note that this gets in the way of using the blang "keywords" in your value language.
2. And
and Or
take a variable number of arguments, so that one can (and probably should) write
(and FOO BAR BAZ QUX)
instead of
(and FOO (and BAR (and BAZ QUX)))
type 'a t
= private
|
True
|
False
|
And of 'a t * 'a t
|
Or of 'a t * 'a t
|
Not of 'a t
|
If of 'a t * 'a t * 'a t
|
Base of 'a
Note that the sexps are not directly inferred from the type below -- there are lots of fancy shortcuts. Also, the sexps for
'a
must not look anything like blang sexps. Otherwiset_of_sexp
will fail.
include Bin_prot.Binable.S1 with type 'a t := 'a t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
val compare : ('a -> 'a -> Core_kernel__.Import.int) -> 'a t -> 'a t -> Core_kernel__.Import.int
val hash_fold_t : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a t -> Base.Hash.state
include Ppx_sexp_conv_lib.Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t
Smart constructors that simplify away constants whenever possible
module type Constructors = sig ... end
include Constructors
val base : 'a -> 'a t
val true_ : _ t
val false_ : _ t
val constant : Core_kernel__.Import.bool -> _ t
function true -> true_ | false -> false_
val not_ : 'a t -> 'a t
val and_ : 'a t Core_kernel__.Import.list -> 'a t
n-ary
And
val or_ : 'a t Core_kernel__.Import.list -> 'a t
n-ary
Or
module O : sig ... end
val constant_value : 'a t -> Core_kernel__.Import.bool Core_kernel__.Import.option
constant_value t = Some b
ifft = constant b
val gather_conjuncts : 'a t -> 'a t Core_kernel__.Import.list
gather_conjuncts t
gathers up all toplevel conjuncts int
. For example,gather_conjuncts (and_ ts) = ts
gather_conjuncts (And (t1, t2)) = gather_conjuncts t1 @ gather_conjuncts t2
gather_conjuncts True = []
gather_conjuncts t = [t]
whent
matches neitherAnd (_, _)
norTrue
val gather_disjuncts : 'a t -> 'a t Core_kernel__.Import.list
gather_disjuncts t
gathers up all toplevel disjuncts int
. For example,gather_disjuncts (or_ ts) = ts
gather_disjuncts (Or (t1, t2)) = gather_disjuncts t1 @ gather_disjuncts t2
gather_disjuncts False = []
gather_disjuncts t = [t]
whent
matches neitherOr (_, _)
norFalse
include Container.S1 with type 'a t := 'a t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
Checks whether the provided element is there, using
equal
.
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
fold t ~init ~f
returnsf (... f (f (f init e1) e2) e3 ...) en
, wheree1..en
are the elements oft
val fold_result : 'a t -> init:'accum -> f:('accum -> 'a -> ('accum, 'e) Base.Result.t) -> ('accum, 'e) Base.Result.t
fold_result t ~init ~f
is a short-circuiting version offold
that runs in theResult
monad. Iff
returns anError _
, that value is returned without any additional invocations off
.
val fold_until : 'a t -> init:'accum -> f:('accum -> 'a -> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) -> finish:('accum -> 'final) -> 'final
fold_until t ~init ~f ~finish
is a short-circuiting version offold
. Iff
returnsStop _
the computation ceases and results in that value. Iff
returnsContinue _
, the fold will proceed. Iff
never returnsStop _
, the final result is computed byfinish
.Example:
type maybe_negative = | Found_negative of int | All_nonnegative of { sum : int } (** [first_neg_or_sum list] returns the first negative number in [list], if any, otherwise returns the sum of the list. *) let first_neg_or_sum = List.fold_until ~init:0 ~f:(fun sum x -> if x < 0 then Stop (Found_negative x) else Continue (sum + x)) ~finish:(fun sum -> All_nonnegative { sum }) ;; let x = first_neg_or_sum [1; 2; 3; 4; 5] val x : maybe_negative = All_nonnegative {sum = 15} let y = first_neg_or_sum [1; 2; -3; 4; 5] val y : maybe_negative = Found_negative -3
val exists : 'a t -> f:('a -> bool) -> bool
Returns
true
if and only if there exists an element for which the provided function evaluates totrue
. This is a short-circuiting operation.
val for_all : 'a t -> f:('a -> bool) -> bool
Returns
true
if and only if the provided function evaluates totrue
for all elements. This is a short-circuiting operation.
val count : 'a t -> f:('a -> bool) -> int
Returns the number of elements for which the provided function evaluates to true.
val sum : (module Base__.Container_intf.Summable with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum
Returns the sum of
f i
for alli
in the container.
val find : 'a t -> f:('a -> bool) -> 'a option
Returns as an
option
the first element for whichf
evaluates to true.
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
Returns the first evaluation of
f
that returnsSome
, and returnsNone
if there is no such element.
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
Returns a minimum (resp maximum) element from the collection using the provided
compare
function, orNone
if the collection is empty. In case of a tie, the first element encountered while traversing the collection is returned. The implementation usesfold
so it has the same complexity asfold
.
val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
include Quickcheckable.S1 with type 'a t := 'a t
val quickcheck_generator : 'a Base_quickcheck.Generator.t -> 'a t Base_quickcheck.Generator.t
val quickcheck_observer : 'a Base_quickcheck.Observer.t -> 'a t Base_quickcheck.Observer.t
val quickcheck_shrinker : 'a Base_quickcheck.Shrinker.t -> 'a t Base_quickcheck.Shrinker.t
Blang.t
sports a substitution monad:
return v
isBase v
(think ofv
as a variable)bind t f
replaces everyBase v
int
withf v
(think ofv
as a variable andf
as specifying the term to substitute for each variable)
Note: bind t f
does short-circuiting, so f
may not be called on every variable in t
.
include Core_kernel__.Std_internal.Monad with type 'a t := 'a t
include Base__.Monad_intf.S_without_syntax with type 'a t := 'a t
module Monad_infix : Base__.Monad_intf.Infix with type 'a t := 'a t
val return : 'a -> 'a t
return v
returns the (trivial) computation that returns v.
val values : 'a t -> 'a Core_kernel__.Import.list
values t
forms the list containing everyv
for whichBase v
is a subexpression oft
val eval : 'a t -> ('a -> Core_kernel__.Import.bool) -> Core_kernel__.Import.bool
eval t f
evaluates the propositiont
relative to an environmentf
that assigns truth values to base propositions.
val eval_set : universe:('elt, 'comparator) Set.t Lazy.t -> ('a -> ('elt, 'comparator) Set.t) -> 'a t -> ('elt, 'comparator) Set.t
eval_set ~universe set_of_base expression
returns the subset of elementse
inuniverse
that satisfyeval expression (fun base -> Set.mem (set_of_base base) e)
.eval_set
assumes, but does not verify, thatset_of_base
always returns a subset ofuniverse
. If this doesn't hold, theneval_set
's result may contain elements not inuniverse
.And set1 set2
represents the elements that are both inset1
andset2
, thus in the intersection of the two sets. Symmetrically,Or set1 set2
represents the union ofset1
andset2
.
val specialize : 'a t -> ('a -> [ `Known of Core_kernel__.Import.bool | `Unknown ]) -> 'a t
specialize t f
partially evaluatest
according to a perhaps-incomplete assignmentf
of the values of base propositions. The following laws (at least partially) characterize its behavior.specialize t (fun _ -> `Unknown) = t
specialize t (fun x -> `Known (f x)) = constant (eval t f)
List.for_all (values (specialize t g)) ~f:(fun x -> g x = `Unknown)
if List.for_all (values t) ~f:(fun x -> match g x with | `Known b -> b = f x | `Unknown -> true) then eval t f = eval (specialize t g) f
val invariant : 'a t -> Core_kernel__.Import.unit
module Stable : sig ... end