package opam-format

  1. Overview
  2. Docs

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

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

type version_constraint = relop * OpamPackage.Version.t

Version constraints for OPAM

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 =
  1. | Empty
  2. | Atom of 'a
  3. | Block of 'a formula
  4. | And of 'a formula * 'a formula
  5. | 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

val check_version_formula : version_formula -> OpamPackage.Version.t -> bool

Checks if a given version satisfies a 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.

A more aggressive version of simplify_version_formula that attempts to find a shorter formula describing the same subset of versions within a given set. The empty formula is returned for an empty set, and the original formula is otherwise returned as is if no versions match.

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 of atoms from a package formula. It the initial formula is not a disjunction, then fail.

val set_to_disjunction : OpamPackage.Set.t -> t -> atom disjunction

Like to_disjunction, but accepts conjunctions within constraint formulas, resolving them using the provided package set. Conjunctions between packages still raise Failure.

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

OCaml

Innovation. Community. Security.