package opam-format

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Untyped generic file format
Filenames
Packages
Variables
Formulas
Repositories
Variable-based filters
Filtered formulas (to express conditional dependencies)
Solver
Command line arguments
Generic command-line definitions with filters
Switches
Misc
Repository and global states

package opam-format

opam-format
- OpamFile
  - Aliases
  - BestEffortRead
  - Changes
  - Comp
  - Config
    
    BestEffort
  - Descr
  - Dot_config
  - Dot_install
  - Environment
  - File_attributes
  - IO_FILE
  - InitConfig
  - LegacyState
  - Lines
  - OPAM
  - Package_index
  - Pinned_legacy
  - PkgList
  - Repo
  - Repo_config_legacy
  - Repos_config
    
    BestEffort
  - Stats
  - SwitchExport
  - SwitchSelections
    
    BestEffort
  - Switch_config
    
    BestEffort
  - Syntax
  - URL
  - Wrappers
- OpamFilter
- OpamFormat
  - I
  - V
- OpamFormatConfig
- OpamFormula
- OpamLineLexer
- OpamPackage
  - Map
  - Name
    
    Map
    
    Set
    
    Op
  - Set
    
    Op
  - Version
    
    Map
    
    Set
    
    Op
- OpamPath
  - Builddir
  - Switch
    
    Default
    
    Overlay
- OpamPp
  - Op
  - STR
- OpamRepositoryName
  - Map
  - Set
    
    Op
- OpamSwitch
  - Map
  - Set
    
    Op
- OpamTypesBase
- OpamVariable
  - Full
    
    Map
    
    Set
    
    Op
  - Map
  - Set
    
    Op

Legend:
Library
Module
Module type
Parameter
Class
Class type

Definitions of many types used throughout

type 'a success = [

| `Successful of 'a

]

Error and continuation handling

type 'a error = [

| `Error of 'a
| `Exception of exn

]

type ('a, 'b) status = [

| 'a success
| 'b error

]

type ('a, 'b) either = ('a, 'b) OpamCompat.Either.t =

| Left of 'a
| Right of 'b

Untyped generic file format

include module type of struct include OpamParserTypes end

Type definitions used by the legacy and the new full position modules

type relop = [

| `Eq
(*
=
*)
| `Neq
(*
!=
*)
| `Geq
(*
>=
*)
| `Gt
(*
>
*)
| `Leq
(*
<=
*)
| `Lt
(*
<
*)

]

Relational operators

type logop = [

| `And
(*
&
*)
| `Or
(*
|
*)

]

Logical operators

type pfxop = [

| `Not
(*
!
*)
| `Defined
(*
?
*)

]

Prefix operators

type file_name = string

type pos = file_name * int * int

Source file positions: (filename, line, column)

type env_update_op = OpamParserTypes.env_update_op =

| Eq
(*
=
*)
| PlusEq
(*
+=
*)
| EqPlus
(*
=+
*)
| ColonEq
(*
:=
*)
| EqColon
(*
=:
*)
| EqPlusEq
(*
=+=
*)

Environment variable update operators

module FullPos = OpamParserTypes.FullPos

OpamParserTypes transitional module with full position types

type value = OpamParserTypes.value =

| Bool of pos * bool
| Int of pos * int
| String of pos * string
| Relop of pos * relop * value * value
| Prefix_relop of pos * relop * value
| Logop of pos * logop * value * value
| Pfxop of pos * pfxop * value
| Ident of pos * string
| List of pos * value list
| Group of pos * value list
| Option of pos * value * value list
| Env_binding of pos * value * env_update_op * value

type opamfile_section = OpamParserTypes.opamfile_section = {

section_kind : string;
section_name : string option;
section_items : opamfile_item list;

}

and opamfile_item = OpamParserTypes.opamfile_item =

| Section of pos * opamfile_section
| Variable of pos * string * value

type opamfile = OpamParserTypes.opamfile = {

file_contents : opamfile_item list;
file_name : file_name;

}

Filenames

type basename = OpamFilename.Base.t

Basenames

type dirname = OpamFilename.Dir.t

Directory names (translated to absolute)

type filename = OpamFilename.t

Filenames

type filename_set = OpamFilename.Set.t

Set of files

type 'a filename_map = 'a OpamFilename.Map.t

Map of files

type std_path =

| Prefix
| Lib
| Bin
| Sbin
| Share
| Doc
| Etc
| Man
| Toplevel
| Stublibs

Predefined installation directories within a switch

type 'a download =

| Up_to_date of 'a
| Not_available of string option * string
(*
Arguments are respectively the short and long version of an error message. The usage is: the first argument is displayed on normal mode (nothing if None), and the second one on verbose mode.
*)
| Result of 'a

Download result

Packages

type package = private OpamPackage.t = {

name : OpamPackage.Name.t;
version : OpamPackage.Version.t;

}

Packages are (name * version) tuple

type package_set = OpamPackage.Set.t

Set of packages

type 'a package_map = 'a OpamPackage.Map.t

Map of packages

type name = OpamPackage.Name.t

Package names

type name_set = OpamPackage.Name.Set.t

Set of package names

type 'a name_map = 'a OpamPackage.Name.Map.t

Map of package names

type version = OpamPackage.Version.t

Package versions

type version_set = OpamPackage.Version.Set.t

Set of package versions

type opam_version = OpamVersion.t

OPAM versions

Variables

type variable = OpamVariable.t

Variables

type full_variable = OpamVariable.Full.t

Fully qualified variables (ie. with the name of sections/sub-sections they appear in)

type variable_contents = OpamVariable.variable_contents =

| B of bool
| S of string
| L of string list

Content of user-defined variables

type variable_map = OpamVariable.variable_contents OpamVariable.Map.t

A map from variables to their contents (i.e an environment)

type package_flag =

| Pkgflag_LightUninstall
(*
The package doesn't require downloading to uninstall
*)
| Pkgflag_Verbose
(*
The package's scripts output is to be displayed to the user
*)
| Pkgflag_Plugin
(*
The package is an opam plugin that will install a opam-<name> exec, and may be auto-installed when doing opam <name>
*)
| Pkgflag_Compiler
(*
Package may be used for 'opam switch'
*)
| Pkgflag_Conf
(*
Virtual package: no source, no install or remove instructions, .install, but likely has depexts
*)
| Pkgflag_Unknown of string
(*
Used for error reporting, otherwise ignored
*)

Opam package flags

module type GenericPackage = sig ... end

At some point we want to abstract so that the same functions can be used over CUDF and OPAM packages

Formulas

type 'a generic_formula = 'a OpamFormula.formula =

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

A generic formula

type atom = OpamFormula.atom

Formula atoms

type formula = OpamFormula.t

Formula over versionned packages

type 'a conjunction = 'a OpamFormula.conjunction

AND formulat

type 'a disjunction = 'a OpamFormula.disjunction

OR formulat

Repositories

type repository_name = OpamRepositoryName.t

Repository names

type 'a repository_name_map = 'a OpamRepositoryName.Map.t

Maps of repository names

type url = OpamUrl.t

type trust_anchors = {

quorum : int;
fingerprints : string list;

}

type repository = {

repo_name : repository_name;
repo_root : dirname;
(*
The root of opam's local mirror for this repo
*)
repo_url : url;
repo_trust : trust_anchors option;

}

Repositories

Variable-based filters

type filter =

| FBool of bool
| FString of string
| FIdent of name option list * variable * (string * string) option
(*
packages (or None for self-ref through "_"), variable name, string converter (val_if_true, val_if_false_or_undef)
*)
| FOp of filter * relop * filter
| FAnd of filter * filter
| FOr of filter * filter
| FNot of filter
| FDefined of filter
| FUndef of filter
(*
Returned by reduce functions when the filter could not be resolved to an atom (due to undefined variables or string expansions). The argument contains the partially reduced filter, where strings may still contain expansions (and are otherwise escaped). Used both for partial evaluation, and error messaging. Not allowed as an argument to other filters
*)

Filtered formulas (to express conditional dependencies)

These are first reduced to only the dependency-flag variables build, doc, dev, test defined in Opam formulas

type 'a filter_or_constraint =

| Filter of filter
| Constraint of relop * 'a

type filtered_formula =
  (name * filter filter_or_constraint OpamFormula.formula) OpamFormula.formula

Solver

type 'a atomic_action = [

| `Remove of 'a
| `Install of 'a

]

Used internally when computing sequences of actions

type 'a highlevel_action = [

| 'a atomic_action
| `Change of [ `Up | `Down ] * 'a * 'a
| `Reinstall of 'a

]

Used to compact the atomic actions and display to the user in a more meaningful way

type 'a inst_action = [

| `Install of 'a
| `Change of [ `Up | `Down ] * 'a * 'a

]

Sub-type of highlevel_action corresponding to an installed package that changed state or version

type 'a concrete_action = [

| 'a atomic_action
| `Build of 'a

]

Used when applying solutions, separates build from install

type 'a action = [

| 'a atomic_action
| 'a highlevel_action
| 'a concrete_action

]

type 'a cause =

| Use of 'a list
| Required_by of 'a list
| Conflicts_with of 'a list
| Upstream_changes
| Requested
| Unknown

The possible causes of an action.

type solver_result =

| Nothing_to_do
| OK of package action list
(*
List of successful actions
*)
| Aborted
| No_solution
| Partial_error of package action list * package action list * package action list
(*
List of successful actions, list of actions with errors, list of remaining undone actions
*)

Solver result

type ('a, 'b) result =

| Success of 'a
| Conflicts of 'b

Solver result

type solver_criteria = [

| `Default
| `Upgrade
| `Fixup

]

type 'a request = {

criteria : solver_criteria;
wish_install : 'a conjunction;
wish_remove : 'a conjunction;
wish_upgrade : 'a conjunction;
extra_attributes : string list;

}

Solver request

type user_action =

| Query
| Install
| Upgrade
| Reinstall
| Remove
| Switch
| Import

user request action

type universe = {

u_packages : package_set;
u_installed : package_set;
u_available : package_set;
u_depends : filtered_formula package_map;
u_depopts : filtered_formula package_map;
u_conflicts : formula package_map;
u_action : user_action;
u_installed_roots : package_set;
u_pinned : package_set;
u_base : package_set;
u_reinstall : package_set;
u_attrs : (string * package_set) list;

}

Solver universe

Command line arguments

type pin_kind = [

| `version
| OpamUrl.backend

]

Pin kind

type shell = OpamStd.Sys.shell =

| SH_sh
| SH_bash
| SH_zsh
| SH_csh
| SH_fish

Shell compatibility modes

Generic command-line definitions with filters

type simple_arg =

| CString of string
| CIdent of string

A command argument

type arg = simple_arg * filter option

Command argument

type command = arg list * filter option

Command

Switches

type switch = OpamSwitch.t

Compiler switches

type switch_set = OpamSwitch.Set.t

Set of compiler switches

type 'a switch_map = 'a OpamSwitch.Map.t

Map of compile switches

type switch_selections = {

sel_installed : package_set;
sel_roots : package_set;
sel_compiler : package_set;
sel_pinned : package_set;

}

Misc

type lock =

| Read_lock of unit -> unit
(*
The function does not modify anything, but it needs the state not to change while it is running.
*)
| Global_lock of unit -> unit
(*
Take the global lock, all subsequent calls to OPAM are blocked.
*)
| Switch_lock of unit -> switch * unit -> unit
(*
Take a global read lock and a switch lock. The first function is called with the read lock, then the second function is called with the returned switch write-locked.
*)
| Global_with_switch_cont_lock of unit -> switch * (unit -> unit)
(*
Call the function in a global lock, then relax to a switch lock and call the function it returned
*)

The different kinds of locks

type file_attribute = OpamFilename.Attribute.t

A line in urls.tx

type file_attribute_set = OpamFilename.Attribute.Set.t

All the lines in urls.txt

type 'a optional = {

c : 'a;
(*
Contents
*)
optional : bool;
(*
Is the contents optional
*)

}

Optional contents

type stats = {

s_install : int;
s_reinstall : int;
s_upgrade : int;
s_downgrade : int;
s_remove : int;

}

Upgrade statistics

type env = (string * string * string option) list

Environement variables: var name, value, optional comment

type env_update = string * env_update_op * string * string option

Environment updates

var, update_op, value, comment

type tags = OpamStd.String.Set.t OpamStd.String.SetMap.t

Repository and global states

type checksums = string list

Checksums

type json = OpamJson.t

JSON