opam-format 2.0~alpha5 · OCaml Package

Formulas on packages, opt. with sub-formulas on versions, and conversion functions

type relop = OpamParserTypes.relop

binary operations (compatible with the Dose type for Cudf operators !)

type version_constraint = relop * OpamPackage.Version.t

Version constraints for OPAM

type atom = OpamPackage.Name.t * version_constraint option

Formula atoms for OPAM

val string_of_atom : atom -> string

Pretty-printing of atoms

val short_string_of_atom : atom -> string

The compact atom format used in requests, "pkgOPvers", with '.' allowed instead of '='

val string_of_atoms : atom list -> string

Prints atoms as a conjunction ("&") using the short format

val check : atom -> OpamPackage.t -> bool

Checks if a package verifies an atom

val packages_of_atoms : OpamPackage.Set.t -> atom list -> OpamPackage.Set.t

Return all packages satisfying the given atoms from a set (i.e. name matching at least one of the atoms, version matching all atoms with the appropriate name)

type 'a conjunction = 'a list

AND formulas

val string_of_conjunction : ('a -> string) -> 'a conjunction -> string

Pretty print AND formulas

type 'a disjunction = 'a list

OR formulas

val string_of_disjunction : ('a -> string) -> 'a disjunction -> string

Pretty print OR formulas

type 'a cnf = 'a disjunction conjunction

CNF formulas (Conjunctive Normal Form)

type 'a dnf = 'a conjunction disjunction

DNF formulas (Disjunctive Normal Form)

val string_of_cnf : ('a -> string) -> 'a cnf -> string

Pretty print CNF formulas

val string_of_dnf : ('a -> string) -> 'a dnf -> string

Pretty print DNF formulas

type 'a formula =

| Empty
| Atom of 'a
| Block of 'a formula
| And of 'a formula * 'a formula
| Or of 'a formula * 'a formula

General formulas

val eval : ('a -> bool) -> 'a formula -> bool

Eval a formula

val partial_eval : 
  ('a -> [ `Formula of 'b formula | `True | `False ]) ->
  'a formula ->
  [ `Formula of 'b formula | `True | `False ]

val check_relop : relop -> int -> bool

Check a relational operator against an integer from compare

val eval_relop : 
  relop ->
  OpamPackage.Version.t ->
  OpamPackage.Version.t ->
  bool

Evaluate a relational operator between versions

val neg_relop : relop -> relop

val string_of_formula : ('a -> string) -> 'a formula -> string

Pretty print a formula

val ands : 'a formula list -> 'a formula

Convert a list of formulas to an AND-formula (Empty formulas are ignored)

val ands_to_list : 'a formula -> 'a formula list

Converts back an AND-formula to a list (flattens top-level ands)

val ors : 'a formula list -> 'a formula

Convert a list of formulas to an OR-formula (Empty formulas are ignored)

val ors_to_list : 'a formula -> 'a formula list

Converts back an OR-formula to a list (flattens top-level ors)

val map : ('a -> 'b formula) -> 'a formula -> 'b formula

Map on atoms. Atoms for which the given function returns Empty will be simply removed

val map_formula : ('a formula -> 'a formula) -> 'a formula -> 'a formula

Maps top-down on a formula

val neg : ('a -> 'a) -> 'a formula -> 'a formula

Negates a formula (given the function to negate atoms)

val iter : ('a -> unit) -> 'a formula -> unit

Iter function

val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b formula -> 'a

Fold function

type version_formula = version_constraint formula

Expressions composed entirely of version constraints

type t = (OpamPackage.Name.t * version_formula) formula

An atom is: name * (relop * version) formula. Examples of valid formulae:

"foo" {> "1" & (<"3" | ="5")}
"foo" {= "1" | > "4"} | ("bar" "bouh")

val cnf_of_formula : 'a formula -> 'a formula

Convert a formula to CNF

val dnf_of_formula : 'a formula -> 'a formula

Convert a formula to DNF

val to_atom_formula : t -> atom formula

Transform a formula where versions can be expressed using formulas to a flat atom formula

val of_atom_formula : atom formula -> t

Convert an atom-formula to a t-formula

val simplify_version_formula : version_formula -> version_formula

Reduces the formula, finding a shorter description of the same version set. Keeps conflicting formula, for documentation, when the set is empty.

Atoms

val atoms : t -> atom list

Return all the atoms

val to_string : t -> string

Pretty print the formula

val to_conjunction : t -> atom conjunction

Return a conjunction. If the initial formula is not a conjunction, then fail.

val of_conjunction : atom conjunction -> t

Return a formula from a conjunction of atoms

val to_disjunction : t -> atom disjunction

Return a disjunction. It the initial formula is not a disjunction, then fail.

val of_disjunction : atom disjunction -> t

Return a formula from a disjunction of atoms

val to_cnf : t -> atom cnf

Return an equivalent CNF formula

val to_dnf : t -> atom dnf

Return an equivalent DNF formula

type 'a ext_package_formula =
  (OpamPackage.Name.t * ('a * version_formula)) formula

Formula over versionned packages with additional flags (used to handle eg. build-deps)

val formula_of_extended : filter:('a -> bool) -> 'a ext_package_formula -> t

Turns an extended package formula to a normal formula, by filtering out the packages on the flags of which filter returns false.

val reduce_extended : 
  filter:('a -> bool option) ->
  'a list ext_package_formula ->
  'a list ext_package_formula

Partially evaluates extended formula flags, removing the atom if it has a flag on which filter is Some false, and removing flags on which filter is Some true

package opam-format

Atoms