Module OpamFormulaSource

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

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

Sourceval compare_relop : relop -> relop -> int
Sourceval all_relop : relop list

A list containing each available operator once.

Sourceval string_of_relop : relop -> string

Returns a string representing the operator in infix syntax, as used in opam files (">", "=", etc.)

Sourcetype version_constraint = relop * OpamPackage.Version.t

Version constraints for OPAM

Sourceval compare_version_constraint : version_constraint -> version_constraint -> int

Formula atoms for OPAM

Sourceval compare_atom : atom -> atom -> int
Sourceval string_of_atom : atom -> string

Pretty-printing of atoms

Sourceval short_string_of_atom : atom -> string

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

Sourceval atom_of_string : string -> atom

Parses a package or atom, in a format similar to short_string_of_atom.

  • raises Failure

    if the format is incorrect

Sourceval string_of_atoms : atom list -> string

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

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

Checks if a package verifies an atom

Sourceval packages_of_atoms : ?disj:bool -> 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). If disj is true, returns packages that satisfy at least one of the constraint of a given name, otherwise that satisfy all constraints.

Sourcetype 'a conjunction = 'a list

AND formulas

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

Pretty print AND formulas

Sourcetype 'a disjunction = 'a list

OR formulas

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

Pretty print OR formulas

CNF formulas (Conjunctive Normal Form)

DNF formulas (Disjunctive Normal Form)

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

Pretty print CNF formulas

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

Pretty print DNF formulas

Sourcetype '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

Sourceval compare_formula : ('a -> 'a -> int) -> 'a formula -> 'a formula -> int
Sourceval eval : ('a -> bool) -> 'a formula -> bool

Eval a formula

Sourceval partial_eval : ('a -> [ `Formula of 'b formula | `True | `False ]) -> 'a formula -> [ `Formula of 'b formula | `True | `False ]
Sourceval check_relop : relop -> int -> bool

Check a relational operator against an integer from compare

Evaluate a relational operator between versions

Sourceval neg_relop : relop -> relop
Sourceval string_of_formula : ('a -> string) -> 'a formula -> string

Pretty print a formula

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

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

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

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

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

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

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

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

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

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

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

Maps top-down on a formula

Sourceval map_up_formula : ('a formula -> 'a formula) -> 'a formula -> 'a formula

Maps bottom-up on a formula (atoms first)

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

Negates a formula (given the function to negate atoms)

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

Iter function

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

Fold function (bottom-up, left-to-right)

Sourceval fold_right : ('a -> 'b -> 'a) -> 'a -> 'b formula -> 'a

Fold function (bottom-up, right-to-left)

Sourceval exists : ('a -> bool) -> 'a formula -> bool

exists f formula scans the whole formula until f atom returns true, in which case it returns true. Returns false otherwise

Sourceval sort : ('a -> 'a -> int) -> 'a formula -> 'a formula

Sort formula, using compare function. `Block` around `Or` and `And` \ are removed.

Sourcetype version_formula = version_constraint formula

Expressions composed entirely of version constraints

Sourceval 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")
Sourceval compare : t -> t -> int
Sourceval verifies : t -> OpamPackage.t -> bool

Returns true if package verifies formula (i.e. it is within at least one package set that is a solution of the formula, and is named in the formula)

Sourceval satisfies_depends : OpamPackage.Set.t -> t -> bool

Checks if a given set of (installed) packages satisfies a formula

Returns the set of names referred to in a formula

Returns the subset of packages possibly matching the formula (i.e. including all disjunction cases)

Sourceval cnf_of_formula : 'a formula -> 'a formula

Convert a formula to CNF

Sourceval formula_to_cnf : 'a formula -> 'a cnf

Convert a formula to CNF, but as a nested list

Sourceval dnf_of_formula : 'a formula -> 'a formula

Convert a formula to DNF

Sourceval formula_to_dnf : 'a formula -> 'a dnf

Convert a formula to DNF, but as a nested list

Sourceval to_atom_formula : t -> atom formula

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

Sourceval of_atom_formula : atom formula -> t

Convert an atom-formula to a t-formula

Sourceval simplify_ineq_formula : ('a -> 'a -> int) -> (relop * 'a) formula -> (relop * 'a) formula option

simplify_ineq_formula comp f returns a canonical version of inequality formula f, based on comparison function comp, where each version appears at most once, and in increasing order. Returns Some Empty if the formula is always true, None if it is always false

Sourceval simplify_version_formula : version_formula -> version_formula option

Like simplify_ineq_formula, but specialised on version formulas

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.

formula_of_version_set set subset generates a formula that is enough to describe all packages of subset and exclude packages otherwise in set

Atoms

Sourceval atoms : t -> atom list

Return all the atoms

Sourceval to_string : t -> string

Pretty print the formula

Sourceval to_conjunction : t -> atom conjunction

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

Sourceval of_conjunction : atom conjunction -> t

Return a formula from a conjunction of atoms

Sourceval to_disjunction : t -> atom disjunction

Return a disjunction of atoms from a package formula. It the initial formula is not a disjunction, then fail.

Sourceval 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.

Sourceval of_disjunction : atom disjunction -> t

Return a formula from a disjunction of atoms

Sourceval to_cnf : t -> atom cnf

Return an equivalent CNF formula

Sourceval to_dnf : t -> atom dnf

Return an equivalent DNF formula