| (/) [OpamFilename.OP] | 
Create a new directory
 | 
| (//) [OpamFilename.OP] | 
Create a new filename
 | 
| (@@+) [OpamProcess.Job.Op] | job1 @@+ fun r -> job2appends the computation of tasks injob2afterjob1 | 
| (@@>) [OpamProcess.Job.Op] | 
Stage a shell command with its continuation, eg:
          | 
| (@@|) [OpamProcess.Job.Op] | job @@| fmapsfon the results ofjob. | 
| A | |
| acolor [OpamGlobals] | |
| acolor_w [OpamGlobals] | |
| action_contents [OpamTypesBase] | 
Extract a package from a package action.
 | 
| add [OpamJson] | |
| add [OpamRepositoryCommand] | 
Add a new repository.
 | 
| add [OpamClient.API.REPOSITORY] | 
Add a new repository.
 | 
| add_extension [OpamFilename] | 
Add a file extension
 | 
| add_pinned_overlay [OpamState] | 
Add overlay files for a pinned package.
 | 
| add_pos [OpamFormat] | 
Adds a position to a Bad_format exception if it doesn't have one yet
 | 
| add_to_env [OpamState] | 
Update an environment.
 | 
| add_to_reinstall [OpamState] | 
Add the given packages to the set of package to reinstall.
 | 
| address_of_string [OpamTypesBase] | 
Parse an address
 | 
| aliases [OpamPath] | 
Compiler aliases
 | 
| all_installed [OpamState] | 
Return all the collection of installed packages, for all the
    available packages
 | 
| all_parens [OpamGlobals] | 
Tells the printer to write parens everywhere
 | 
| ands [OpamFormula] | 
Convert a list of formulas to an AND-formula ( Emptyformulas are
    ignored) | 
| ands_to_list [OpamFormula] | 
Converts back an AND-formula to a list (flattens top-level ands)
 | 
| ano [Opam_check] | |
| apply [OpamSolution] | 
Apply a solution returned by the solver.
 | 
| arch [OpamGlobals] | |
| archive [OpamPath.Repository] | 
Return the archive for a given package:
      $opam/repo/$repo/archives/$NAME.$VERSION.tar.gz
 | 
| archive [OpamPath] | 
Archive file: $opam/archives/$NAME.$VERSION+opam.tar.gz
 | 
| archives_dir [OpamPath.Repository] | 
Return the archive folder: $opam/repo/$repo/archives/
 | 
| archives_dir [OpamPath] | 
Archives dir
 | 
| assoc [OpamFormat] | 
Get the value of a field
 | 
| assoc_default [OpamFormat] | 
Get the value of a field.
 | 
| assoc_list [OpamFormat] | 
Get the value associated to a variable.
 | 
| assoc_option [OpamFormat] | 
Get the value of a field.
 | 
| assoc_sections [OpamFormat] | 
Get sections
 | 
| assoc_string_list [OpamFormat] | 
Get the string list associated to a variable.
 | 
| atom_of_package [OpamSolution] | 
Return a simple atom, with no version constrain, from a package
 | 
| atoms [OpamFormula] | 
Return all the atoms
 | 
| atoms_of_packages [OpamSolution] | 
Return a list of simple atoms (ie.
 | 
| author [OpamFile.OPAM] | 
Author(s)
 | 
| available [OpamFile.OPAM] | 
Availability formula (OS + compiler constraints)
 | 
| B | |
| backends [OpamRepository] | |
| backup [OpamPath.Switch] | 
Backup file for state export
 | 
| backup [OpamPath] | 
Backup file for state export
 | 
| backup_dir [OpamPath.Switch] | 
The directory where backups are stored for this switch
 | 
| backup_dir [OpamPath] | 
The directory where global backups are stored
 | 
| bad_format [OpamFormat] | 
Raise  Bad_format. | 
| base [OpamFilename.Attribute] | 
Get remote filename
 | 
| base_package_names [OpamState] | 
Return the names of packages marked as "base" in the current compiler
    description
 | 
| base_packages [OpamState] | 
Return the installed base packages of the current compiler
 | 
| basename [OpamFilename] | 
Return the base name
 | 
| basename_dir [OpamFilename] | 
Return the deeper directory name
 | 
| bin [OpamPath.Switch] | 
Installed binaries: $opam/$switch/bin
 | 
| bin [OpamFile.Dot_install] | 
List of files to install in $bin/
 | 
| body [OpamFile.Descr] | 
Return the body
 | 
| browse [OpamFile.Repo] | 
Base URL for browsing packages on the WWW
 | 
| bug_reports [OpamFile.OPAM] | 
Where to post bug reports.
 | 
| build [OpamPath.Switch] | 
Temporary folders used to decompress and compile
      the corresponding archives:
      $opam/$switch/build/$packages
 | 
| build [OpamFile.Comp] | 
Options to give to build the package.
 | 
| build [OpamFile.OPAM] | 
List of command to run for building the package
 | 
| build_and_install_package [OpamAction] | 
Build and install a package from its downloaded source.
 | 
| build_config [OpamPath.Switch] | 
Temporary location of config files:       $opam/$switch/build/$packages/$name.config
 | 
| build_dir [OpamPath.Switch] | 
Temporary folder: $opam/$switch/build
 | 
| build_doc [OpamGlobals] | |
| build_doc [OpamFile.OPAM] | 
Commands to build the documentation
 | 
| build_env [OpamFile.OPAM] | 
List of environment variables to set-up for the build
 | 
| build_install [OpamPath.Switch] | 
Temporary location of install files:       $opam/$switch/build/$package/$name.install
 | 
| build_ocaml [OpamPath.Switch] | 
Temporary folders used to decompress and compile the OCaml
      compiler: $opam/$switch/build/ocaml
 | 
| build_test [OpamGlobals] | |
| build_test [OpamFile.OPAM] | 
Commands to build and run the tests
 | 
| C | |
| catch [OpamProcess.Job] | 
Catch exceptions raised within a job
 | 
| chdir [OpamSystem] | 
Change the current working directory
 | 
| check [OpamFormula] | 
Checks if a package verifies an atom
 | 
| check [OpamState] | 
Apply a function while taking the right locks
 | 
| check_availability [OpamSolution] | 
Checks that the atoms can possibly be verified (individually) in a package
    set.
 | 
| check_digest [OpamRepository] | |
| check_relop [OpamFormula] | 
Check a relational operator against an integer from compare
 | 
| check_solution [OpamSolution] | 
Raise an error if no solution is found or in case of error.
 | 
| check_suffix [OpamFilename] | 
Check whether a file has a given suffix
 | 
| check_version [OpamRepository] | |
| checksum [OpamFilename] | 
Compute the MD5 digest a file.
 | 
| checksum [OpamFile.URL] | 
Archive checksum
 | 
| checksum_dir [OpamFilename] | 
Compute the MD5 digest for all files in a directory.
 | 
| chmod [OpamFilename] | 
Change file permissions
 | 
| chop_extension [OpamFilename] | 
Remove the file extension
 | 
| cleandir [OpamFilename] | 
Clean the contents of a directory.
 | 
| cleanup [OpamProcess] | 
Should be called after process termination, to cleanup temporary files.
 | 
| cleanup_package_artefacts [OpamAction] | 
Removes auxiliary files related to a package, after checking that
    they're not needed (even in other switches)
 | 
| cnf_of_formula [OpamFormula] | 
Convert a formula to CNF
 | 
| color [OpamGlobals] | |
| color_when [OpamGlobals] | |
| colorise [OpamGlobals] | 
not nestable
 | 
| command [OpamSystem] | command cmdexecutes the commandcmdin the correct OPAM
    environment. | 
| command [OpamProcess] | |
| command_exists [OpamSystem] | 
Test whether a command exists in the environment.
 | 
| commands [OpamSystem] | commands cmdsexecutes the commandscmdsin the correct OPAM
    environment. | 
| commands [OpamFilter] | 
Processes filters evaluation in a command list: parameter expansion and
    conditional filtering
 | 
| commands_variables [OpamFilter] | 
Extracts variables appearing in a list of commands
 | 
| compare [OpamRepository.O] | |
| compare [OpamRepository] | |
| compare [OpamVersion] | 
Version comparison
 | 
| compare [OpamCompiler.Version] | 
Compare OCaml versions
 | 
| compat_preferences [OpamGlobals] | |
| compiler_comp [OpamPath.Repository] | 
Compiler files: $opam/repo/$repo/compilers/XXX/$OVERSION.comp
 | 
| compiler_comp [OpamPath] | 
Compiler files: $opam/compilers/$VERSION/$COMP.comp
 | 
| compiler_comp [OpamState] | 
Return the compiler description
 | 
| compiler_descr [OpamPath.Repository] | 
Compiler description files: $opam/repo/$repo/compilers/XXX/$OVERSION.descr
 | 
| compiler_descr [OpamPath] | 
Compiler description files: $opam/compilers/$VERSION/$COMP.descr
 | 
| compiler_files [OpamRepository] | |
| compiler_index [OpamRepository] | |
| compiler_index [OpamPath] | 
Return the repository index: $opam/repo/compiler-index
 | 
| compiler_index [OpamState] | 
Build a map which says in which repository the latest metadata for
    a given compiler is.
 | 
| compiler_repository_state [OpamState] | 
Repository state
 | 
| compiler_state [OpamRepository] | |
| compiler_state [OpamState] | 
Global compiler state
 | 
| compilers [OpamRepository] | |
| compilers [Opam_admin_top] | 
All defined compilers in the current repo
 | 
| compilers [OpamPath] | 
Compiler subdir $opam/compilers/$VERSION/$COMP
 | 
| compilers_dir [OpamPath.Repository] | 
Compiler files: $opam/repo/$repo/compilers/
 | 
| compilers_dir [OpamPath] | 
Compiler files: $opam/compilers/
 | 
| compilers_with_prefixes [OpamRepository] | |
| complete [OpamScript] | |
| complete_zsh [OpamScript] | |
| config [OpamPath.Repository] | 
Return the repository config: $opam/repo/$repo/config
 | 
| config [OpamPath.Switch] | 
Compile and link flags for a given package:       $opam/$switch/lib/$name/opam.config
 | 
| config [OpamPath] | 
Main configuration file: $opam/config
 | 
| config_dir [OpamPath.Switch] | 
Configuration folder: $opam/$switch/config
 | 
| configure [OpamFile.Comp] | 
Options to give to the "./configure" command
 | 
| confirm [OpamGlobals] | 
Ask the user to press Y/y/N/n to continue (returns a boolean).
 | 
| conflicts [OpamFile.OPAM] | 
Package conflicts
 | 
| copy [OpamSystem] | copy src dstcopiessrctodst. | 
| copy [OpamFilename] | 
Copy a file
 | 
| copy_dir [OpamFilename] | 
Copy a directory
 | 
| copy_files [OpamFilename] | copy_if_check t src dstcopies all the files from one directory
    to another. | 
| copy_files [OpamState] | 
Return the files for a given package
 | 
| copy_in [OpamFilename] | 
Copy a file in a directory.
 | 
| create [OpamVariable.Full] | 
Create a variable local for a given library/syntax extension
 | 
| create [OpamPath.Repository] | 
Repository local path: $opam/repo/<name>
 | 
| create [OpamFilename.Attribute] | 
Constructor
 | 
| create [OpamFilename] | 
Create a filename from a Dir.t and a basename
 | 
| create [OpamFile.URL] | |
| create [OpamFile.Repo] | |
| create [OpamFile.Dot_config] | 
Create a new .config file (containing only variables)
 | 
| create [OpamFile.OPAM] | 
Create an opam file
 | 
| create [OpamFile.Config] | 
Creation
 | 
| create_preinstalled [OpamFile.Comp] | 
Create a pre-installed compiler description file
 | 
| create_system_compiler_description [OpamState] | 
Create $opam/compilers/system.com.
 | 
| criteria [OpamFile.Config] | |
| cudf_file [OpamGlobals] | |
| curl_command [OpamGlobals] | |
| current [OpamVersion] | 
The current OPAM version
 | 
| current_nopatch [OpamVersion] | 
The current OPAM version, truncated (only MAJOR.MINOR)
 | 
| cwd [OpamFilename] | 
Return the current working directory
 | 
| D | |
| debug [OpamGlobals] | |
| debug_level [OpamGlobals] | |
| default [OpamRepository] | |
| default [OpamSwitch] | 
Default switch
 | 
| default [OpamRepositoryName] | 
Default repository name
 | 
| default_address [OpamRepository] | |
| default_dl_jobs [OpamGlobals] | |
| default_external_solver [OpamGlobals] | |
| default_jobs [OpamGlobals] | |
| default_opam_dir [OpamGlobals] | |
| default_preferences [OpamGlobals] | |
| default_repository_address [OpamGlobals] | |
| default_repository_name [OpamGlobals] | |
| depends [OpamFile.OPAM] | 
Package dependencies
 | 
| depexts [OpamFile.OPAM] | 
External dependencies
 | 
| depopts [OpamFile.OPAM] | 
Optional dependencies
 | 
| descr [OpamPath.Repository] | 
Return the description file for a given package:
      $opam/repo/$repo/packages/XXX/$NAME.VERSION/descr
 | 
| descr [OpamPath.Switch.Overlay] | 
Descr orverlay
 | 
| descr [OpamPath] | 
Description file: $opam/packages/$NAME/$NAME.$VERSION/descr
 | 
| descr [OpamState] | 
Return the Descr file for the given package
 | 
| descr_opt [OpamState] | 
Return the Descr file for the given package
 | 
| dev_package [OpamPath.Switch] | 
Build dir for a given pinned package:       $opam/$switch/packages.dev/$name.$version/
 | 
| dev_package [OpamPath] | 
Temporary folder for dev packages $opam/packages.dev/$NAME.$VERSION/
 | 
| dev_packages [OpamState] | 
Get all the development packages.
 | 
| dev_packages_dir [OpamPath.Switch] | 
Build dir for all pinned packages:       $opam/$switch/packages.dev/
 | 
| dev_packages_dir [OpamPath] | 
Temporary folder for dev packages $opam/packages.dev/
 | 
| dev_repo [OpamFile.OPAM] | 
The package source repository address
 | 
| diff [OpamVCS.VCS] | 
Check whether the staging area is empty.
 | 
| digest [OpamFilename] | 
Compute the MD5 digest of a file
 | 
| dir [OpamRepository] | |
| dir [OpamPath.Switch.Overlay] | 
Switch metadata overlay (over the global metadata):         $opam/$switch/overlay/
 | 
| dir_is_empty [OpamSystem] | |
| dir_is_empty [OpamFilename] | |
| directories_with_links [OpamSystem] | directories_with_links dirreturns the directories in the directorydir. | 
| dirname [OpamFilename] | 
Return the directory name
 | 
| dirname_dir [OpamFilename] | 
Return the parent directory
 | 
| dirs [OpamSystem] | 
Return the list of directories in the current directory.
 | 
| dirs [OpamFilename] | 
List the sub-directory (do not recurse)
 | 
| disp_status_line [OpamGlobals] | |
| display_setup [OpamState] | 
Display the global and user configuration for OPAM.
 | 
| dl_jobs [OpamGlobals] | |
| dl_jobs [OpamFile.Config] | 
Return the number of download jobs
 | 
| dl_jobs [OpamState] | 
Download Jobs
 | 
| dl_tool [OpamFile.Config] | |
| dnf_of_formula [OpamFormula] | 
Convert a formula to DNF
 | 
| do_not_copy_files [OpamGlobals] | |
| doc [OpamPath.Switch] | 
Documentation path for a given package:
      $opam/$switch/doc/$name
 | 
| doc [OpamFile.Dot_install] | 
List of doc files
 | 
| doc [OpamFile.OPAM] | 
API documentation
 | 
| doc_dir [OpamPath.Switch] | 
Documentation path: $opam/$switch/doc/
 | 
| dontwait [OpamProcess] | 
Like  wait, but returns None immediately if the process hasn't ended | 
| dot_config [OpamState] | 
Return the .config file for the given package
 | 
| download [OpamSystem] | 
download compiler sources
 | 
| download [OpamFilename] | 
download a remote file in a given directory.
 | 
| download_archive [OpamState] | 
Download the OPAM-package archive ($name.$version+opam.tar.gz)
 | 
| download_as [OpamFilename] | 
same as  download, but with a specified destination filename instead of a
    directory | 
| download_dir [OpamTypesBase] | 
Upcast a downloaded directory.
 | 
| download_file [OpamTypesBase] | 
Upcast a downloaded file.
 | 
| download_package [OpamAction] | 
Downloads the source for a package to the local cache.
 | 
| download_retry [OpamGlobals] | |
| download_tool [OpamGlobals] | |
| download_tool_env [OpamGlobals] | |
| download_upstream [OpamState] | 
Download the upstream archive, add the eventual additional files
    and return the directory.
 | 
| dry_run [OpamProcess.Job] | 
Same as  runbut doesn't actually run any shell command,
      and feed a dummy result to the cont. | 
| dry_run_background [OpamProcess] | 
Similar to  run_background, except that no process is created, and a dummy
    process (suitable for dry_wait_one) is returned. | 
| dry_wait_one [OpamProcess] | 
Similar to  wait_onefor simulations, to be used withdry_run_background | 
| dryrun [OpamGlobals] | |
| dump_state [OpamState] | |
| E | |
| edit [OpamPinCommand] | 
Let the user edit a pinned package's opam file.
 | 
| edit [OpamClient.API.PIN] | |
| editor [OpamGlobals] | |
| empty [OpamFormat] | 
The empty file
 | 
| empty [OpamFile.OPAM] | |
| empty [OpamFile.IO_FILE] | 
Empty file
 | 
| ends_with [OpamFilename] | 
Check whether a filename ends with a given suffix
 | 
| env [OpamFile.Comp] | 
Environment variable to set-up before running commands in the
      subtree
 | 
| env [OpamConfigCommand] | 
Display the current environment.
 | 
| env [OpamClient.API.CONFIG] | 
Display environment.
 | 
| env_external_solver [OpamGlobals] | |
| env_of_list [OpamFilename] | 
Turns an assoc list into an array suitable to be provided as environment
 | 
| eq_atom [OpamSolution] | 
Return an atom with a strict version constraint
 | 
| eq_atom_of_package [OpamSolution] | 
Returns an atom with a strict version constraint from a package
 | 
| eq_atoms_of_packages [OpamSolution] | 
Return a list of constrained atoms from a set of packages
 | 
| equal [OpamRepository.O] | |
| errmsg [OpamGlobals] | 
Message without prefix, reformat or newline, to stderr (useful to continue
    error messages without repeating " ERROR") | 
| error [OpamGlobals] | |
| error_and_exit [OpamGlobals] | |
| etc [OpamPath.Switch] | 
Etc directory for a given package:       $opam/$switch/etc/$package
 | 
| etc [OpamFile.Dot_install] | 
List of etc files
 | 
| etc_dir [OpamPath.Switch] | 
Etc directory: $opam/$switch/etc
 | 
| eval [OpamFormula] | 
Eval a formula
 | 
| eval [OpamFilter] | 
Computes the value of a filter.
 | 
| eval_relop [OpamFormula] | 
Evaluate a relational operator between versions
 | 
| eval_relop [OpamCompiler.Version] | 
Evaluate a relational operator between OCaml versions
 | 
| eval_string [OpamState] | 
The shell command to run by the user to set his OPAM environement ( eval
    `opam config env`) | 
| eval_to_bool [OpamFilter] | 
Like  to_valuebut casts the result to a bool. | 
| eval_to_string [OpamFilter] | 
Like  to_valuebut casts the result to a string | 
| exec [OpamFilename] | 
Execute a list of commands in a given directory
 | 
| exec [OpamConfigCommand] | 
Execute a command in a subshell
 | 
| exec [OpamClient.API.CONFIG] | 
Execute a command in a subshell with the right environment variables.
 | 
| exists [OpamVCS.VCS] | 
Test whether the given repository is correctly initialized.
 | 
| exists [OpamFilename] | 
Returns true if the file exists and is a regular file or a symlink to one
 | 
| exists_dir [OpamFilename] | 
Does the directory existsb ?
 | 
| exit [OpamGlobals] | |
| expand_interpolations_in_file [OpamFilter] | 
Rewrites  basename.in tobasename, expanding interpolations | 
| expand_string [OpamFilter] | 
Rewrites string interpolations within a string
 | 
| export [OpamSwitchCommand] | 
Export a file which contains the installed packages.
 | 
| export [OpamClient.API.SWITCH] | 
Export the packages to a file.
 | 
| external_solver [OpamGlobals] | |
| external_solver_ref [OpamGlobals] | |
| external_tags [OpamGlobals] | |
| extract [OpamSystem] | extract filename dirnameextracts the archivefilenameintodirname. | 
| extract [OpamFilename] | 
Extract an archive in a given directory (it rewrites the root to
    match  Dir.tdir if needed) | 
| extract_generic_file [OpamFilename] | 
Extract a generic file
 | 
| extract_in [OpamSystem] | extract_in filename dirnameextracts the archivefilenameintodirname. | 
| extract_in [OpamFilename] | 
Extract an archive in a given directory (which should already exists)
 | 
| extract_package [OpamAction] | 
Extracts and patches the source of a package
 | 
| extract_prefix [OpamRepository] | |
| F | |
| fake [OpamGlobals] | |
| features [OpamFile.OPAM] | 
Contents of the 'features' field
 | 
| fetch [OpamVCS.VCS] | 
Fetch changes from upstream.
 | 
| file [OpamRepository] | |
| files [OpamSystem] | 
Return the list of files in the current directory.
 | 
| files [OpamPath.Repository] | 
files $opam/repo/$repo/packages/XXX/$NAME.$VERSION/files
 | 
| files [OpamPath.Switch.Overlay] | 
Files overlay
 | 
| files [OpamPath] | 
Additional files: $opam/packages/$NAME/$NAME.$VERSION/files
 | 
| files [OpamFilename] | 
List all the filename.
 | 
| files [OpamState] | 
Return the files/ directory overlay for the given package
 | 
| files_with_links [OpamSystem] | files_with_links dirreturns the files in the directorydir. | 
| filter_compilers [Opam_admin_top] | 
Turn a list of glob patterns into a proper filtering function on
    compiler names.
 | 
| filter_deps [OpamTypesBase] | |
| filter_env [OpamState] | 
The main Filter.env value to be used to resolve variables in filters
 | 
| filter_ident_of_string [OpamTypesBase] | 
Parses the data suitable for a filter.FIdent from a string.
 | 
| filter_packages [Opam_admin_top] | 
Turn a list of glob patterns into a proper filtering function on
    package names.
 | 
| finally [OpamProcess.Job] | 
Register an exception-safe finaliser in a job.
 | 
| find_backend [OpamRepository] | |
| find_backend_by_kind [OpamRepository] | |
| find_installed_package_by_name [OpamState] | 
Return the installed package with the right name
 | 
| find_opam_file_in_source [OpamState] | 
Looks up an 'opam' file for the given named package in a source directory
 | 
| find_packages_by_name [OpamState] | 
Return all the packages with the given name
 | 
| find_repository [OpamState] | 
Find a given repostiory.
 | 
| find_repository_opt [OpamState] | 
Find a given repostiory.
 | 
| fix_compiler_descriptions [OpamRepositoryCommand] | 
Fix the compiler descriptions and display the changes if  verboseis set. | 
| fix_descriptions [OpamRepositoryCommand] | 
Fix all the package and compiler descriptions.
 | 
| fix_descriptions_hook [OpamState] | 
Update hook
 | 
| fix_package_descriptions [OpamRepositoryCommand] | 
Fix the the package descriptions and display the changes if
     verboseis set. | 
| fixup [OpamClient.API] | 
Recovers from an inconsistent universe
 | 
| flags [OpamFile.OPAM] | 
The package flags that are present for this package.
 | 
| flock [OpamSystem] | 
Acquires a lock on the given file.
 | 
| fold_down_left [OpamFilter] | 
Folds on the tree of a filter
 | 
| fold_left [OpamFormula] | 
Fold function
 | 
| formatted_msg [OpamGlobals] | |
| formula_of_extended [OpamFormula] | 
Turns an extended package formula to a normal formula, by filtering out
    the packages on the flags of which  filterreturnsfalse. | 
| full [OpamVersion] | 
The full version (current + git)
 | 
| full [OpamFile.Descr] | 
Return the full description
 | 
| full_action_contents [OpamTypesBase] | 
Extract a packages from a package action.
 | 
| funlock [OpamSystem] | 
Releases an acquired locl
 | 
| G | |
| get_all_section_by_kind [OpamFormat] | 
Get all the sections of a certain kind
 | 
| get_current [OpamCompiler] | 
Return the current compiler at its currently installed version
 | 
| get_env_var [OpamState] | 
Check for user-defined variable overwrite.
 | 
| get_full_env [OpamState] | 
Get the current environment with OPAM specific additions.
 | 
| get_opam_env [OpamState] | 
Get only environment modified by OPAM.
 | 
| get_section_by_kind [OpamFormat] | 
Get one section of a certain kind
 | 
| get_solver_criteria [OpamGlobals] | 
Get the currently configured solver criteria as a string
 | 
| get_system [OpamCompiler] | 
Return the system compiler at is current version.
 | 
| git [OpamVersion] | 
The 'git' version of OPAM
 | 
| global [OpamVariable.Full] | 
Create a global variable
 | 
| global_config [OpamPath.Switch] | 
Global config for the switch:       $opam/$switch/config/global-config.config
 | 
| global_config [OpamGlobals] | |
| global_lock [OpamClient] | 
Call an unsafe function while taking the global lock.
 | 
| global_start_time [OpamGlobals] | |
| global_variable_names [OpamState] | 
Lists of available variables and their description
 | 
| guess_version_control [OpamTypesBase] | 
Scan the given directory for version control
 | 
| H | |
| handle_install [Opamlfind] | |
| has_flag [OpamFile.OPAM] | 
Check the package for the given flag.
 | 
| hash [OpamRepository.O] | |
| header_error [OpamGlobals] | |
| header_msg [OpamGlobals] | |
| home [OpamGlobals] | |
| homepage [OpamFile.OPAM] | 
Homepage(s)
 | 
| I | |
| ident_bool [OpamFilter] | 
Like  ident_value, but casts the result to a bool | 
| ident_of_var [OpamFilter] | 
Wraps a full_variable into a fident accessor
 | 
| ident_string [OpamFilter] | 
Like  ident_value, but casts the result to a string | 
| ident_value [OpamFilter] | 
Resolves a filter ident.
 | 
| ignore_errors [OpamProcess.Job] | 
Ignore all non-fatal exceptions raised by job and return default
 | 
| import [OpamSwitchCommand] | 
Import a file which contains the packages to install.
 | 
| import [OpamClient.API.SWITCH] | 
Import the packages from a file.
 | 
| in_dir [OpamSystem] | in_dir dir fnevaluatesfnin the directorydir | 
| in_dir [OpamFilename] | 
Evaluate a function in a given directory
 | 
| info [OpamClient.API] | 
Display a general summary of a collection of packages.
 | 
| init [OpamRepository] | |
| init [OpamVCS.VCS] | 
Init a repository.
 | 
| init [OpamPath] | 
Init scripts
 | 
| init [OpamClient.API] | 
Initialize the client a consistent state.
 | 
| install [OpamSystem] | install ?exec src dstcopies filesrcas filedstusinginstall. | 
| install [OpamPath.Switch] | 
Installed files for a given package:       $opam/$switch/install/$name.install
 | 
| install [OpamFilename] | 
Installs a file to a destination.
 | 
| install [OpamFile.OPAM] | 
List of command to run for installing the package
 | 
| install [OpamSwitchCommand] | 
Like  install_contbut runs the continuation already | 
| install [OpamClient.API.SWITCH] | 
Install the given compiler.
 | 
| install [OpamClient.API] | 
Install the given list of packages.
 | 
| install_compiler [OpamState] | 
Install the given compiler
 | 
| install_cont [OpamSwitchCommand] | 
Install a new switch.
 | 
| install_dir [OpamPath.Switch] | 
Installed files: $opam/$switch/install/
 | 
| install_global_config [OpamState] | 
(Re-)install the configuration for a given root and switch
 | 
| install_metadata [OpamState] | 
Copy the repository metadata into the global state.
 | 
| install_packages [OpamSwitchCommand] | 
Install a compiler's base packages
 | 
| installed [Opam_check] | |
| installed [OpamPath.Switch] | 
List of installed packages with their version:
      $opam/$switch/installed
 | 
| installed_map [OpamState] | 
Return a map from package names to package installed version
 | 
| installed_roots [OpamPath.Switch] | 
List of packages explicitly installed by the user:       $opam/$switch/installed.roots
 | 
| installed_timestamp [OpamState] | 
Returns a timestamp when the given package was last installed
 | 
| installed_versions [OpamState] | 
Return a map containing the switch where a given package is installed.
 | 
| internal_error [OpamSystem] | 
Raise  Internal_error | 
| interrupt [OpamProcess] | 
Send SIGINT to a process (or SIGKILL on Windows)
 | 
| invalid_fields [OpamFormat] | 
Find all the invalid fields
 | 
| is_compiler_installed [OpamState] | 
Is a compiler installed ?
 | 
| is_dev_package [OpamState] | 
Check whether a package is a development package
 | 
| is_exec [OpamSystem] | 
Checks if a file is an executable (regular file with execution
    permission)
 | 
| is_exec [OpamFilename] | 
Is an executable ?
 | 
| is_explicit [OpamFile.OPAM] | 
Returns true if the given OPAM file contains 'name' or 'version' fields
 | 
| is_failure [OpamProcess] | 
Is the process result a failure ?
 | 
| is_locally_pinned [OpamState] | 
Is the package locally pinned ? (ie.
 | 
| is_name_installed [OpamState] | 
Check whether a package name is installed
 | 
| is_package_installed [OpamState] | 
Return whether a package is installed
 | 
| is_pinned [OpamState] | 
Is the package name pinned ?
 | 
| is_self_upgrade [OpamGlobals] | |
| is_success [OpamProcess] | 
Is the process result a success ?
 | 
| is_switch_installed [OpamState] | 
Is a switch installed ?
 | 
| is_symlink [OpamFilename] | 
Is a symlink ?
 | 
| is_tar_archive [OpamSystem] | 
Test whether the file is an archive, by looking as its extension
 | 
| is_valid [OpamFormat] | 
Check whether a list of items contains only valid variable definitions
 | 
| is_verbose_command [OpamProcess] | |
| iter [OpamFormula] | 
Iter function
 | 
| iter_compilers [Opam_admin_top] | |
| iter_compilers_gen [Opam_admin_top] | 
Similarly for compiler descriptions
 | 
| iter_packages [Opam_admin_top] | 
Quicker interface when considering a single type of file
 | 
| iter_packages_gen [Opam_admin_top] | 
Maps on the files of every package.
 | 
| J | |
| jobs [OpamGlobals] | |
| jobs [OpamFile.Config] | 
Return the number of jobs
 | 
| jobs [OpamState] | 
Jobs
 | 
| K | |
| keep_build_dir [OpamGlobals] | |
| kind [OpamFile.URL] | 
Backend kind (could be curl/rsync/git/darcs/hg at the moment)
 | 
| kind [OpamFile.Comp] | 
Return the url kind
 | 
| kind_of_pin_option [OpamTypesBase] | 
Get the pin kind from a pin option
 | 
| L | |
| label [Opam_check] | |
| lib [OpamPath.Switch] | 
Library path for a given package:
      $opam/$switch/lib/$name
 | 
| lib [OpamFile.Dot_install] | 
List of files to install in $lib/
 | 
| lib_dir [OpamPath.Switch] | 
Library path: $opam/$switch/lib
 | 
| libexec [OpamFile.Dot_install] | 
Executable files under lib/
 | 
| libraries [OpamFile.OPAM] | 
List of exported libraries
 | 
| license [OpamFile.OPAM] | 
License(s)
 | 
| link [OpamSystem] | link src dstlinkssrctodst. | 
| link [OpamFilename] | 
Symlink a file.
 | 
| link_dir [OpamFilename] | 
Link a directory
 | 
| link_in [OpamFilename] | 
Symlink a file in a directory
 | 
| list [OpamCompiler] | 
List the compiler available in the global state.
 | 
| list [OpamSwitchCommand] | 
List all the available compiler switches.
 | 
| list [OpamRepositoryCommand] | 
List the available repositories.
 | 
| list [OpamPinCommand] | 
List the pinned packages.
 | 
| list [OpamConfigCommand] | 
Display the content of all available variables
 | 
| list [OpamClient.API.PIN] | 
List the current pinned packages.
 | 
| list [OpamClient.API.SWITCH] | 
List the available compiler descriptions.
 | 
| list [OpamClient.API.REPOSITORY] | 
Display the list of repositories.
 | 
| list [OpamClient.API.CONFIG] | 
Display variables and their contents.
 | 
| list [OpamClient.API] | 
Display all available packages that matches any of the
      regexps.
 | 
| load_env_state [OpamState] | 
Load state associated to env variables.
 | 
| load_state [OpamState] | 
Load the client state.
 | 
| local [OpamRepository] | |
| lock [OpamPath.Switch] | 
lock file: $opam/lock
 | 
| lock [OpamPath] | 
lock file
 | 
| lock_retries [OpamGlobals] | |
| log [OpamRepository] | |
| log [OpamPath] | 
Log dir $opam/log
 | 
| log [OpamGlobals] | log section ~level fmt args. | 
| log_limit [OpamGlobals] | |
| log_line_limit [OpamGlobals] | |
| logop_of_string [OpamTypesBase] | 
Raises Invalid_argument
 | 
| M | |
| magic [OpamVersion] | 
Magic string, always of length 8
 | 
| main [OpamParser] | |
| main [OpamLineLexer] | |
| maintainer [OpamFile.OPAM] | 
Package maintainer(s)
 | 
| major [OpamVersion] | 
Extracts the major version
 | 
| make [OpamFile.Comp] | 
Options to give to the "make" command
 | 
| make_archive [OpamRepository] | |
| make_bool [OpamFormat] | 
Create a boolean
 | 
| make_command [OpamSystem] | 
Make a comman suitable for OpamProcess.Job.
 | 
| make_command [OpamFormat] | 
Create a command
 | 
| make_command_text [OpamProcess] | 
Returns a label suitable for printing the summary of running commands.
 | 
| make_commands [OpamFormat] | 
Create a list of commands
 | 
| make_compiler_constraint [OpamFormat] | 
Build a compiler constraint
 | 
| make_env_variable [OpamFormat] | 
Making
 | 
| make_ext_formula [OpamFormat] | 
Make an AND formula where constraints are extended with leading keywords
 | 
| make_features [OpamFormat] | 
Make features list
 | 
| make_filter [OpamFormat] | 
Creation
 | 
| make_flag [OpamFormat] | 
Create a package flag
 | 
| make_formula [OpamFormat] | 
Build a formula where AND are implicit.
 | 
| make_group [OpamFormat] | 
Create a group of 'things'
 | 
| make_ident [OpamFormat] | 
Create an ident
 | 
| make_index_tar_gz [OpamHTTP] | |
| make_int [OpamFormat] | 
Create an integer
 | 
| make_libraries [OpamFormat] | 
Create a list of libraries/syntax
 | 
| make_list [OpamFormat] | 
Create a list of 'things'
 | 
| make_opt_formula [OpamFormat] | 
Build a formula where OR are implicit.
 | 
| make_option [OpamFormat] | 
Create a value and its optional arguments
 | 
| make_os_constraint [OpamFormat] | 
Build an OS constraint
 | 
| make_pair [OpamFormat] | 
Create a pair
 | 
| make_section [OpamFormat] | 
Create a file section
 | 
| make_single_command [OpamFormat] | |
| make_string [OpamFormat] | 
Create a string
 | 
| make_string_list [OpamFormat] | 
Create a list of strings
 | 
| make_string_pair [OpamFormat] | 
Create a pair of strings
 | 
| make_tags [OpamFormat] | 
Make tags
 | 
| make_urls_txt [OpamHTTP] | |
| make_variable [OpamFormat] | 
Create a variable
 | 
| makecmd [OpamGlobals] | |
| man [OpamFile.Dot_install] | 
Man pages
 | 
| man_dir [OpamPath.Switch] | 
Man pages path: $opam/$switch/man/.
 | 
| map [OpamFormula] | 
Map on atoms.
 | 
| map [OpamFormat] | 
map a file
 | 
| map_formula [OpamFormula] | 
Maps top-down on a formula
 | 
| map_success [OpamTypesBase] | 
Map on a solver result
 | 
| md5 [OpamFilename.Attribute] | 
MD5 digest of the remote file
 | 
| mem_repository [OpamState] | 
Check whether a repository exists.
 | 
| message [OpamVersion] | 
Display the version message
 | 
| messages [OpamFile.OPAM] | 
Messages to display before taking action
 | 
| mirrors [OpamFile.URL] | |
| misc [OpamFile.Dot_install] | 
List of other files to install
 | 
| mkdir [OpamSystem] | 
Create a directory.
 | 
| mkdir [OpamFilename] | 
Create a directory
 | 
| move [OpamFilename] | 
Move a file
 | 
| move_dir [OpamFilename] | 
Move a directory
 | 
| msg [OpamGlobals] | |
| N | |
| name [OpamFile.Comp] | 
Return the compiler name
 | 
| name [OpamFile.OPAM] | 
Package name
 | 
| name_opt [OpamFile.OPAM] | |
| name_to_string [OpamTypes.GenericPackage] | |
| neg [OpamFormula] | 
Negates a formula (given the function to negate atoms)
 | 
| neg_relop [OpamFormula] | |
| no_base_packages [OpamGlobals] | |
| no_checksums [OpamGlobals] | |
| no_self_upgrade [OpamGlobals] | |
| nopatch [OpamVersion] | 
Major+minor version, strips the patch version
 | 
| not_installed [OpamSwitch] | 
Display a nice error message when a switch is not installed.
 | 
| note [OpamGlobals] | |
| O | |
| ocaml_natdynlink_available [OpamSystem] | 
Checks if native dynlink is available with the current OCaml compiler
 | 
| ocaml_native_available [OpamSystem] | 
Returns true if the "ocamlopt" is available in the current switch
 | 
| ocaml_opt_available [OpamSystem] | 
Returns true if the ".opt" version of the current OCaml compiler is
    available
 | 
| ocaml_version [OpamSystem] | 
Return the version of the current OCaml compiler.
 | 
| ocaml_version [OpamFile.OPAM] | 
Compiler constraint
 | 
| ocamlfind_command [Opamlfind] | |
| of_atom_formula [OpamFormula] | 
Convert an atom-formula to a t-formula
 | 
| of_basename [OpamFilename] | 
Create a file from a basename and the current working directory
    as dirname
 | 
| of_conjunction [OpamFormula] | 
Return a formula from a conjunction of atoms
 | 
| of_disjunction [OpamFormula] | 
Return a formula from a disjunction of atoms
 | 
| of_filename [OpamCompiler] | 
Convert a filename into a compiler name.
 | 
| of_list [OpamProcess.Job] | 
Converts a list of commands into a job that returns None on success, or
      the first failed command and its result.
 | 
| of_string [OpamRepository] | |
| of_string [OpamFile.Descr] | 
Create an abstract description file from a string
 | 
| of_string_list [OpamFilename.Attribute] | |
| opam [OpamPath.Repository] | 
Return the OPAM file for a given package:
      $opam/repo/$repo/packages/XXX/$NAME.$VERSION/opam
 | 
| opam [OpamPath.Switch.Overlay] | 
OPAM overlay:         $opam/$switch/cache/$name.$version/opam
 | 
| opam [OpamPath] | 
OPAM files: $opam/packages/$NAME/$NAME.$VERSION/opam
 | 
| opam [OpamState] | 
Return the OPAM file for the given package
 | 
| opam_opt [OpamState] | 
Return the OPAM file for the given package
 | 
| opam_version [OpamFile.Repo] | 
The minimum OPAM version required for this repository
 | 
| opam_version [OpamFile.Comp] | 
Get OPAM version
 | 
| opam_version [OpamFile.OPAM] | 
Get OPAM version.
 | 
| opam_version [OpamFile.Config] | 
Return the OPAM version
 | 
| open_in [OpamFilename] | 
Open a channel from a given file.
 | 
| open_out [OpamFilename] | |
| opt_eval_to_bool [OpamFilter] | 
Same as  eval_to_bool, but takes an option as filter and returns alwaystrueonNone,falsewhen the filter isUndefined. | 
| ors [OpamFormula] | 
Convert a list of formulas to an OR-formula ( Emptyformulas are
    ignored) | 
| ors_to_list [OpamFormula] | 
Converts back an OR-formula to a list (flattens top-level ors)
 | 
| os [OpamGlobals] | |
| os [OpamFile.OPAM] | 
OS constraint
 | 
| os_string [OpamGlobals] | |
| output [OpamJson] | |
| P | |
| package [OpamVariable.Full] | 
Return the package the variable is defined in
 | 
| package [OpamPath.Switch.Overlay] | 
Switch metadata overlay (over the global metadata):         $opam/$switch/overlay/$name.$version
 | 
| package_files [OpamRepository] | |
| package_important_files [OpamRepository] | |
| package_index [OpamRepository] | |
| package_index [OpamPath] | 
Return the repository index: $opam/repo/package-index
 | 
| package_index [OpamState] | 
Builds a map which says in which repository the latest metadata
    for a given package are.
 | 
| package_partial_state [OpamState] | 
Global & partial package state.
 | 
| package_repository_partial_state [OpamState] | 
Repository & partial package state.
 | 
| package_repository_state [OpamState] | 
Repository state
 | 
| package_state [OpamRepository] | |
| package_state [OpamState] | 
Global package state.
 | 
| package_variable_names [OpamState] | |
| packages [Opam_check] | |
| packages [OpamRepository] | |
| packages [Opam_admin_top] | 
All defined packages in the current repo
 | 
| packages [OpamPath.Repository] | 
Package folder: $opam/repo/$repo/packages/XXX/$NAME.$VERSION
 | 
| packages [OpamPath] | 
Package sub-directory $opam/packages/$NAME/$NAME.$VERSION/
 | 
| packages [OpamFile.Comp] | 
Packages to install immediately after the creation of OCaml
 | 
| packages_dir [OpamPath.Repository] | 
Packages folder: $opam/repo/$repo/packages
 | 
| packages_dir [OpamPath] | 
Package directroy $opam/packages/
 | 
| packages_of_atoms [OpamState] | 
Return all packages satisfying one of the given atoms from a state
 | 
| packages_with_prefixes [OpamRepository] | |
| parse_bool [OpamFormat] | 
Parse a boolean
 | 
| parse_command [OpamFormat] | 
Parse a command
 | 
| parse_commands [OpamFormat] | 
Parse a list of commands
 | 
| parse_compiler_constraint [OpamFormat] | 
Parse compiler constraints
 | 
| parse_compiler_version [OpamFormat] | 
Parse compiler versions
 | 
| parse_env_variable [OpamFormat] | 
Parsing
 | 
| parse_ext_formula [OpamFormat] | 
Parse an AND formula where constraints are extended with leading keywords
 | 
| parse_features [OpamFormat] | 
Parse features list
 | 
| parse_filter [OpamFormat] | 
Parsing
 | 
| parse_flag [OpamFormat] | 
Parse a package flag
 | 
| parse_formula [OpamFormat] | 
Parse package formula where AND are implicit:  x y -> x & y | 
| parse_group [OpamFormat] | 
Parse a group of 'things'
 | 
| parse_ident [OpamFormat] | 
Parse an ident
 | 
| parse_int [OpamFormat] | 
Parse an integer
 | 
| parse_libraries [OpamFormat] | 
Parse a list of libraries/syntax
 | 
| parse_list [OpamFormat] | 
Parse a list of 'things'
 | 
| parse_list_list [OpamFormat] | 
Parse a list of list of 'things'
 | 
| parse_messages [OpamFormat] | 
Parse a list of commands
 | 
| parse_opt_formula [OpamFormat] | 
Parse optional package formula where OR are implicit:  x y -> x | y | 
| parse_option [OpamFormat] | 
Parse a value and its option of 'things'
 | 
| parse_or [OpamFormat] | 
Try to parse the value using function from the list.
 | 
| parse_os_constraint [OpamFormat] | 
Parse an OS constraint
 | 
| parse_package_name [OpamFormat] | |
| parse_package_version [OpamFormat] | |
| parse_pair [OpamFormat] | 
Parse a pair of strings
 | 
| parse_single_command [OpamFormat] | 
Unfiltered argument list
 | 
| parse_single_option [OpamFormat] | 
Parse a value and a single optional value
 | 
| parse_single_string [OpamFormat] | 
Parse a single string
 | 
| parse_string [OpamFormat] | 
Parse a string
 | 
| parse_string_list [OpamFormat] | 
Parse a list of strings
 | 
| parse_string_option [OpamFormat] | 
Parse a string with an optional argument
 | 
| parse_tags [OpamFormat] | 
Parse tags
 | 
| parse_url [OpamTypesBase] | 
Guess an address kind using url suffixes ( .git, etc.) and prefixes
    (http://, etc.). | 
| pass_on [Opamlfind] | |
| patch [OpamSystem] | 
Apply a patch file in the current directory.
 | 
| patch [OpamFilename] | 
Apply a patch to a directory
 | 
| patches [OpamFile.Comp] | 
Return the list of patches to apply
 | 
| patches [OpamFile.OPAM] | 
Patches
 | 
| path_sep [OpamSystem] | 
The separator character for the PATH variable
 | 
| perm [OpamFilename.Attribute] | 
File permission
 | 
| pfxop_of_string [OpamTypesBase] | 
Raises Invalid_argument
 | 
| pin [OpamPinCommand] | 
Pin a package.
 | 
| pin [OpamClient.API.PIN] | 
Set a package pinning.
 | 
| pin_kind_auto [OpamGlobals] | |
| pin_kind_of_string [OpamTypesBase] | 
Pretty-printing of pin kinds.
 | 
| pin_of_url [OpamTypesBase] | 
Get a pin_option from address and kind
 | 
| pin_option_of_string [OpamTypesBase] | 
Read pin options args.
 | 
| pinned [OpamPath.Switch] | 
Pinned package file: $opam/$switch/pinned
 | 
| pinned [OpamState] | 
Returns the versionned pinned package.
 | 
| pinned_opt [OpamState] | 
Returns the versionned pinned package, or  Noneif not pinned | 
| pinned_packages [OpamState] | 
The set of pinned packages in the state (warning: costly)
 | 
| pos_null [OpamTypesBase] | 
The empty file position
 | 
| post_messages [OpamFile.OPAM] | 
Messages to display at end of install
 | 
| prefixes [OpamCompiler] | 
List the compiler available in a directory (and their prefix)
 | 
| preinstalled [OpamFile.Comp] | 
Is it a pre-installed compiler description file
 | 
| prettify [OpamFilename] | 
Prettify a filename: replace /path/to/opam/foo by <opam>/foo, replace /path/to/home/foo by ~/foo
 | 
| prettify_dir [OpamFilename] | 
Prettify a dirname.
 | 
| print_env_warning_at_init [OpamState] | 
Print a warning if the environment is not set-up properly on init.
 | 
| print_env_warning_at_switch [OpamState] | 
Print a warning if the environment is not set-up properly on switch.
 | 
| print_stats [OpamSystem] | 
Print stats
 | 
| print_stats [OpamGlobals] | |
| print_stats [OpamFile] | 
Display statistics about file access.
 | 
| priority [OpamRepositoryCommand] | 
Set a repository priority.
 | 
| priority [OpamClient.API.REPOSITORY] | 
Set-up repository priority.
 | 
| process [Opam_stats] | |
| process_error [OpamSystem] | 
raise  Process_error | 
| pull_archive [OpamRepository] | |
| pull_archive [OpamRepository.BACKEND] | |
| pull_repo [OpamRepository.BACKEND] | |
| pull_url [OpamRepository] | |
| pull_url [OpamRepository.BACKEND] | |
| pull_url_and_fix_digest [OpamRepository] | |
| R | |
| raise_on_process_error [OpamSystem] | 
raise  Process_errorif the process didn't return 0 | 
| raw [OpamFilename] | 
Creation from a raw string (as http://<path>)
 | 
| raw_config [OpamPath.Repository] | 
Return the repository config: $opam/repo/$repo/config
 | 
| raw_dir [OpamFilename] | 
Creation from a raw string (as http://<path>)
 | 
| read [OpamSystem] | read filenamereturns the contents offilename | 
| read [OpamGlobals] | |
| read [OpamFilename] | 
Retrieves the contents from the hard disk.
 | 
| read [OpamFile.IO_FILE] | 
Read file contents.
 | 
| read_command_output [OpamSystem] | read_command_output cmdexecutes the commandcmdin the
    correct OPAM environment and return the lines from stdout if the command
    exists normally. | 
| read_from_channel [OpamFile.IO_FILE] | 
Read from channel.
 | 
| read_lines [OpamProcess] | 
Misc
 | 
| read_lock [OpamClient] | 
Call an unsafe function while checking that no lock is already held.
 | 
| readlink [OpamFilename] | 
Read a symlinked file
 | 
| real_path [OpamSystem] | real_path preturns the real path associated top:..are
    expanded and relative paths become absolute. | 
| rebuild_state_cache [OpamState] | 
Rebuild the state cache.
 | 
| rec_dirs [OpamSystem] | rec_dirs dirreturn the list list of all directories recursively
    (going through symbolink links). | 
| rec_dirs [OpamFilename] | 
List the sub-directory recursively
 | 
| rec_files [OpamSystem] | rec_files dirreturns the list of all files indir,
    recursively. | 
| rec_files [OpamFilename] | 
List all the filenames, recursively
 | 
| redirect [OpamFile.Repo] | 
Redirections.
 | 
| redirect [OpamState] | 
Check the redirections.
 | 
| register [OpamLocal] | |
| register [OpamHg] | |
| register [OpamHTTP] | |
| register [OpamGit] | |
| register [OpamDarcs] | |
| register_backend [OpamRepository] | |
| reinstall [OpamPath.Switch] | 
Packages to reinstall on next upgrade:       $opam/$switch/reinstall
 | 
| reinstall [OpamSwitchCommand] | 
Reinstall the given compiler switch.
 | 
| reinstall [OpamClient.API.SWITCH] | 
Reinstall the given compiler.
 | 
| reinstall [OpamClient.API] | 
Reinstall the given set of packages.
 | 
| relop_of_string [OpamTypesBase] | 
Raises Invalid_argument
 | 
| relop_of_string [OpamFormula] | 
Parsing relops
 | 
| remote_archive [OpamPath.Repository] | 
Remote archive $remote/archives/$NAME.$VERSION.tar.gz
 | 
| remote_compilers_dir [OpamPath.Repository] | 
Remote compiler files: $remote/compilers
 | 
| remote_packages_dir [OpamPath.Repository] | 
Remote package files: $remote/packages
 | 
| remote_repo [OpamPath.Repository] | 
Remote repo file
 | 
| removal_needs_download [OpamAction] | 
Find out if the package source is needed for uninstall
 | 
| remove [OpamSystem] | remove filenameremovesfilename. | 
| remove [OpamFilename] | 
Removes everything in  filenameif existed. | 
| remove [OpamFile.OPAM] | 
List of command to run for removing the package
 | 
| remove [OpamSwitchCommand] | 
Remove the given compiler switch.
 | 
| remove [OpamRepositoryCommand] | 
Remove a repository.
 | 
| remove [OpamClient.API.SWITCH] | 
Remove the given compiler.
 | 
| remove [OpamClient.API.REPOSITORY] | 
Remove a repository.
 | 
| remove [OpamClient.API] | 
Remove the given list of packages.
 | 
| remove_dir [OpamSystem] | remove_dir filenameremovesfilename. | 
| remove_file [OpamSystem] | remove_file filenameremovesfilename. | 
| remove_metadata [OpamState] | 
Remove some metadata from the global state if they are not used
    anymore.
 | 
| remove_overlay [OpamState] | 
Remove all overlay files
 | 
| remove_package [OpamAction] | 
Remove a package.
 | 
| remove_prefix [OpamFilename] | 
Remove a prefix from a file name
 | 
| remove_state_cache [OpamState] | 
Remove the state cache
 | 
| remove_suffix [OpamFilename] | 
Remove a suffix from a filename
 | 
| repo [Opam_admin_top] | 
The current repo (taken from CWD !)
 | 
| repo [OpamPath.Repository] | 
Return the repo file
 | 
| repositories [OpamFile.Config] | 
Return the list of repository
 | 
| repository_and_prefix_of_compiler [OpamState] | 
Return the active repository for a given compiler
 | 
| repository_and_prefix_of_package [OpamState] | 
Get the active repository for a given package
 | 
| repository_kind_of_pin_kind [OpamTypesBase] | 
Convert a pin kind to a repository kind
 | 
| repository_kind_of_string [OpamTypesBase] | 
Parser of repository kinds.
 | 
| repository_of_package [OpamState] | 
Get the active repository for a given package
 | 
| req_checksums [OpamGlobals] | |
| reset [OpamVCS.VCS] | 
Reset the master branch of the repository to match the remote
      repository state.
 | 
| resolve [OpamSolution] | 
Resolve an user request
 | 
| resolve_and_apply [OpamSolution] | 
Call the solver to get a solution and then call  apply. | 
| revision [OpamRepository] | |
| revision [OpamVCS.VCS] | 
Return the HEAD revision.
 | 
| revision [OpamRepository.BACKEND] | |
| rmdir [OpamFilename] | 
Remove a directory
 | 
| root [OpamPath.Switch] | 
Root dir: $opam/$switch
 | 
| root [OpamPath] | 
Default root path
 | 
| root_dir [OpamGlobals] | |
| root_dir_tmp [OpamGlobals] | 
The initial value of root_dir, set in the tmpdir before initialised
 | 
| rsync_dirs [OpamLocal] | |
| rsync_file [OpamLocal] | |
| run [OpamProcess.Job] | 
Sequential run of a job
 | 
| run [OpamProcess] | run commandsynchronously call the commandcommand.cmdwith
    argumentscommand.args. | 
| run_background [OpamProcess] | 
Same as  run, but doesn't wait. | 
| S | |
| safe_mode [OpamGlobals] | |
| safe_read [OpamFile.IO_FILE] | 
Read file contents.
 | 
| sanitize_atom_list [OpamSolution] | 
Takes a "raw" list of atoms (from the user), and match it to existing
    packages.
 | 
| sbin [OpamPath.Switch] | 
Installed system binaries: $opam/$switch/sbin
 | 
| sbin [OpamFile.Dot_install] | 
List of files to install in $sbin/
 | 
| search_files [OpamGlobals] | |
| sections [OpamFormat] | 
Get all the sections from a list of items
 | 
| self_upgrade_bootstrapping_value [OpamGlobals] | |
| set_git [OpamVersion] | 
Side-effect to set the git version later in the build
 | 
| set_output [OpamJson] | |
| set_url [OpamRepositoryCommand] | 
Change the registered address of a repo
 | 
| set_url [OpamClient.API.REPOSITORY] | 
Set-up repository url.
 | 
| setup [OpamConfigCommand] | 
Update the global and user configuration to use OPAM.
 | 
| setup [OpamClient.API.CONFIG] | 
Global and user setup of OPAM.
 | 
| setup_list [OpamConfigCommand] | 
Display the global and user configuration for OPAM.
 | 
| setup_list [OpamClient.API.CONFIG] | 
Display global and user informations about OPAM setup.
 | 
| share [OpamPath.Switch] | 
Share directory for a given package:       $opam/$switch/share/$package
 | 
| share [OpamFile.Dot_install] | 
List of architecture-independent files
 | 
| share_dir [OpamPath.Switch] | 
Shared directory: $opam/$switch/share
 | 
| share_root [OpamFile.Dot_install] | 
List of files under the more general share prefix
 | 
| short_string_of_atom [OpamFormula] | 
The compact atom format used in requests, "pkgOPvers", with '.' allowed instead
    of '='
 | 
| show [OpamGlobals] | |
| show [OpamSwitchCommand] | 
Display the current compiler switch.
 | 
| show [OpamClient.API.SWITCH] | 
Display the name of the current compiler.
 | 
| simplify_version_formula [OpamFormula] | 
Reduces the formula, finding a shorter description of the same version set.
 | 
| single_command [OpamFilter] | 
Process a simpler command, without filters
 | 
| skip_version_checks [OpamGlobals] | |
| slog [OpamRepository] | |
| slog [OpamGlobals] | 
Helper to pass stringifiers to log (use  log "%a" (slog to_string) xrather thanlog "%s" (to_string x)to avoid costly unneeded
    stringifications | 
| solver [OpamFile.Config] | |
| solver_preferences [OpamGlobals] | 
Solver preference bindings.
 | 
| solver_timeout [OpamGlobals] | |
| sort [OpamRepository] | |
| sorted_repositories [OpamState] | 
Sort repositories by priority.
 | 
| sources_needed [OpamAction] | 
Compute the set of packages which will need to be downloaded to apply a
    solution
 | 
| spec [Opam_check] | |
| src [OpamFile.Comp] | 
Return the url of the compiler
 | 
| starts_with [OpamFilename] | 
Check whether a filename starts by a given Dir.t
 | 
| state_cache [OpamPath] | 
State cache
 | 
| static_base_packages [OpamState] | 
A few historical package names used as base for compilers (base-xxx)
 | 
| status_line [OpamGlobals] | 
Display a dynamic status line to stdout, that will be erased on next output.
 | 
| strict [OpamGlobals] | |
| string_of_address [OpamTypesBase] | 
Print an address
 | 
| string_of_atom [OpamFormula] | 
Pretty-printing of atoms
 | 
| string_of_atoms [OpamFormula] | 
Prints atoms as a conjunction ("&") using the short format
 | 
| string_of_bad_format [OpamFormat] | |
| string_of_cause [OpamTypesBase] | 
Pretty-prints the cause of an action
 | 
| string_of_channel [OpamSystem] | 
Return the contents of a channel.
 | 
| string_of_cnf [OpamFormula] | 
Pretty print CNF formulas
 | 
| string_of_command [OpamProcess] | |
| string_of_conjunction [OpamFormula] | 
Pretty print AND formulas
 | 
| string_of_disjunction [OpamFormula] | 
Pretty print OR formulas
 | 
| string_of_dnf [OpamFormula] | 
Pretty print DNF formulas
 | 
| string_of_download [OpamTypesBase] | 
Corresponding user message
 | 
| string_of_file [OpamFormat] | 
Print a file
 | 
| string_of_formula [OpamFormula] | 
Pretty print a formula
 | 
| string_of_generic_file [OpamTypesBase] | |
| string_of_logop [OpamTypesBase] | |
| string_of_pfxop [OpamTypesBase] | |
| string_of_pin_kind [OpamTypesBase] | 
Parsing of pin kinds
 | 
| string_of_pin_option [OpamTypesBase] | 
Convert a pin option to a string
 | 
| string_of_pos [OpamTypesBase] | 
Prints a file position
 | 
| string_of_relop [OpamTypesBase] | |
| string_of_relop [OpamFormula] | 
Pretty-printing of relops
 | 
| string_of_repositories [OpamState] | 
Pretty print a map of repositories
 | 
| string_of_repository_kind [OpamTypesBase] | 
Pretty-print repository kinds.
 | 
| string_of_result [OpamProcess] | 
Pretty printing of process.
 | 
| string_of_shell [OpamTypesBase] | 
Pretty-print
 | 
| string_of_upload [OpamTypesBase] | 
Pretty-print
 | 
| string_of_value [OpamFormat] | 
Print a value
 | 
| string_of_values [OpamFormat] | 
Print a list of values
 | 
| string_of_variable_contents [OpamVariable] | 
Pretty print of variable contents
 | 
| stublibs [OpamPath.Switch] | 
DLL paths
 | 
| stublibs [OpamFile.Dot_install] | 
C bindings
 | 
| subst [OpamConfigCommand] | 
Substitute files
 | 
| subst [OpamClient.API.CONFIG] | 
Substitute files.
 | 
| substs [OpamFile.OPAM] | 
File substitutions
 | 
| sum [OpamSolution] | 
Stats
 | 
| switch [OpamGlobals] | |
| switch [OpamFile.Config] | 
Return the OCaml switch
 | 
| switch [OpamSwitchCommand] | 
Like  switch_contbut runs the continuation already. | 
| switch [OpamClient.API.SWITCH] | 
Set the given switch, installing it if necessary.
 | 
| switch_cont [OpamSwitchCommand] | 
Switch to the given compiler switch.
 | 
| switch_eval [OpamScript] | |
| switch_lock [OpamClient] | 
Call an unsafe function while taking the current switch lock.
 | 
| switch_reinstall_hook [OpamState] | 
Switch reinstall hook.
 | 
| sync_archives [OpamGlobals] | |
| synopsis [OpamFile.Descr] | 
Return the first line
 | 
| syntax [OpamFile.OPAM] | 
List of exported syntax extensions
 | 
| system [OpamGlobals] | |
| system [OpamCompiler] | 
System compiler
 | 
| system_ocamlc_version [OpamSystem] | 
Return the version of the system compiler
 | 
| system_ocamlc_where [OpamSystem] | 
Return the path where the system ocamlc library is installed
 | 
| T | |
| tags [OpamFile.OPAM] | 
Classification tags
 | 
| temp_file [OpamSystem] | 
Create a tempory file in ~/.opam/logs/<name>XXX
 | 
| template [OpamFile.OPAM] | 
Create an OPAM package template filled with common options
 | 
| text_of_command [OpamProcess] | |
| timer [OpamGlobals] | |
| timestamp [OpamGlobals] | |
| tmp_opam [OpamPath.Switch.Overlay] | 
OPAM temp overlay (for user editing):         $opam/$switch/cache/$name.$version/opam_
 | 
| to_1_0 [OpamFile.Comp] | 
Convert to OPAM 1.0
 | 
| to_1_0 [OpamFile.OPAM] | 
Convert to OPAM 1.0
 | 
| to_atom_formula [OpamFormula] | 
Transform a formula where versions can be expressed using formulas
    to a flat atom formula
 | 
| to_attribute [OpamFilename] | 
Convert a filename to an attribute, relatively to a root
 | 
| to_cnf [OpamFormula] | 
Return an equivalent CNF formula
 | 
| to_conjunction [OpamFormula] | 
Return a conjunction.
 | 
| to_disjunction [OpamFormula] | 
Return a disjunction.
 | 
| to_dnf [OpamFormula] | 
Return an equivalent DNF formula
 | 
| to_json [OpamRepository.O] | |
| to_json [OpamRepository] | |
| to_list_dir [OpamFilename] | 
Turn a full path into a list of directory names
 | 
| to_string [OpamRepository.O] | |
| to_string [OpamRepository] | |
| to_string [OpamJson] | |
| to_string [OpamFormula] | 
Pretty print the formula
 | 
| to_string [OpamFilter] | 
Pretty-print
 | 
| to_string_list [OpamFilename.Attribute] | |
| token [OpamLexer] | |
| toplevel [OpamPath.Switch] | 
toplevel path: $opam/$switch/lib/toplevel
 | 
| toplevel [OpamFile.Dot_install] | 
List of toplevel files
 | 
| touch [OpamFilename] | 
Create an empty file
 | 
| U | |
| unavailable_reason [OpamState] | 
Returns an explanation why a package is not currently available
 | 
| universe [OpamState] | 
Create a universe from the current state
 | 
| unknown [OpamCompiler] | 
Errors
 | 
| unknown_package [OpamState] | 
Returns a message about an atom that doesn't exist
 | 
| unpin [OpamPinCommand] | 
Unpin packages.
 | 
| unpin [OpamClient.API.PIN] | |
| up_to_date_env [OpamState] | 
Check if the shell environment is in sync with the current OPAM switch
 | 
| update [OpamRepository] | |
| update [OpamRepositoryCommand] | 
Update the given repository from its upstream.
 | 
| update [OpamClient.API] | 
Refresh the available packages.
 | 
| update_cache [OpamPath.Repository] | 
Update cache
 | 
| update_cache [OpamPath] | 
Update cache
 | 
| update_compiler_index [OpamRepositoryCommand] | 
Update the compiler index.
 | 
| update_dev_package [OpamState] | 
Updates a dev or pinned package from its upstream; returns true
    if changed, false otherwise
 | 
| update_dev_packages [OpamState] | update_dev_packages tchecks for upstream changes for packages
    first in the switch cache and then in the global cache. | 
| update_dev_packages [OpamRepositoryCommand] | 
Update the given dev packages.
 | 
| update_metadata [OpamAction] | 
Update package metadata
 | 
| update_package_index [OpamRepositoryCommand] | 
Update the package index.
 | 
| update_pinned_package [OpamState] | 
Updates a dev pinned package from its upstream; returns true if changed,
    false otherwise
 | 
| update_pinned_packages [OpamState] | 
A subset of update_dev_packages that only takes packages names and only
    works on pinned packages.
 | 
| update_setup [OpamState] | 
Update the user configuration.
 | 
| update_setup_interactive [OpamState] | 
Update the global and user configuration by asking some questions.
 | 
| update_switch_config [OpamState] | 
Write the right compiler switch in ~/.opam/config
 | 
| upgrade [OpamClient.API] | 
Find a consistent state where most of the installed packages are
      upgraded to their latest version, within the given constraints.
 | 
| upload_dir [OpamPath.Repository] | 
Return the upload folder for a given version:
      $opam/repo/$repo/upload/
 | 
| upstream [OpamFile.Repo] | 
Base URL for browsing OPAM repository source on the WWW
 | 
| url [OpamPath.Repository] | 
urls $opma/repo/$repo/package/XXX/$NAME.$VERSION/url
 | 
| url [OpamPath.Switch.Overlay] | 
URL overlay:         $opam/$switch/overlay/$name.$version/url
 | 
| url [OpamPath] | 
URL files: $opam/packages/$NAME/$NAME.$VERSION/url
 | 
| url [OpamFile.URL] | 
URL address
 | 
| url [OpamState] | 
Return the URL file for the given package
 | 
| url_checksum [OpamRepository] | |
| url_of_locally_pinned_package [OpamState] | 
Return the URL file associated with a locally pinned package.
 | 
| usage [Opam_check] | |
| use_external_solver [OpamGlobals] | |
| utf8 [OpamGlobals] | |
| utf8_msgs [OpamGlobals] | |
| utf8_when [OpamGlobals] | |
| V | |
| validate [OpamFile.OPAM] | 
Runs several sanity checks on the opam file; returns a list of warnings.
 | 
| validate_file [OpamFile.OPAM] | 
Same as  validate, but operates on a file, which allows catching parse
      errors too. | 
| value [OpamParser] | |
| value_pos [OpamFormat] | 
Get the position out of a value
 | 
| values_pos [OpamFormat] | 
Get the position of the first element out of a value list
 | 
| variable [OpamVariable.Full] | 
Return the variable name
 | 
| variable [OpamFile.Dot_config] | 
Top-level variables
 | 
| variable [OpamConfigCommand] | 
Display the content of a given variable
 | 
| variable [OpamClient.API.CONFIG] | 
Display a given variable content.
 | 
| variables [OpamFormat] | 
Get all the variable definitions from a list of items
 | 
| variables [OpamFilter] | 
Returns all the variables appearing in a filter (including the ones within
    string interpolations
 | 
| variables [OpamFile.Dot_config] | 
The list of top-level variables
 | 
| verbose [OpamJson] | |
| verbose [OpamGlobals] | |
| verbose_for_base_commands [OpamSystem] | 
Returns true if the default verbose level for base commands (cp, mv, etc.)
    is reached
 | 
| verbose_level [OpamGlobals] | |
| version [OpamFile.Comp] | 
Return the compiler version
 | 
| version [OpamFile.OPAM] | 
Package version
 | 
| version [OpamCompiler] | 
Return the compiler version
 | 
| version [OpamGitVersion] | |
| version_opt [OpamFile.OPAM] | |
| version_to_string [OpamTypes.GenericPackage] | |
| versionned_files [OpamVCS.VCS] | 
Returns the list of files under version control
 | 
| W | |
| wait [OpamProcess] | wait pwaits for the processuspto end and returns its results. | 
| wait_one [OpamProcess] | 
Wait for the first of the listed processes to terminate, and return its
    termination status
 | 
| warning [OpamGlobals] | |
| warns_to_string [OpamFile.OPAM] | 
Utility function to print validation results
 | 
| with_available [OpamFile.OPAM] | |
| with_bug_reports [OpamFile.OPAM] | 
Construct using  bug_reports | 
| with_build [OpamFile.Comp] | |
| with_build [OpamFile.OPAM] | 
Construct as  build | 
| with_checksum [OpamFile.URL] | 
Constructor
 | 
| with_configure [OpamFile.Comp] | |
| with_conflicts [OpamFile.OPAM] | |
| with_contents [OpamFilename] | 
Apply a function on the contents of a file
 | 
| with_criteria [OpamFile.Config] | |
| with_current_opam_version [OpamFile.Config] | 
Update opam-version to the current one
 | 
| with_depends [OpamFile.OPAM] | 
Construct as  depends | 
| with_depexts [OpamFile.OPAM] | 
Construct using  depexts | 
| with_depopts [OpamFile.OPAM] | 
Construct as  depopts | 
| with_dev_repo [OpamFile.OPAM] | |
| with_features [OpamFile.OPAM] | |
| with_flags [OpamFile.OPAM] | |
| with_flock [OpamFilename] | 
File locks
 | 
| with_install [OpamFile.OPAM] | |
| with_libraries [OpamFile.OPAM] | 
Construct as  libraries | 
| with_maintainer [OpamFile.OPAM] | 
Construct as  maintainer | 
| with_make [OpamFile.Comp] | |
| with_messages [OpamFile.OPAM] | |
| with_name [OpamFile.OPAM] | 
construct as  name | 
| with_name_opt [OpamFile.OPAM] | |
| with_ocaml_version [OpamFile.OPAM] | 
Construct as  compiler_version | 
| with_opam_version [OpamFile.OPAM] | 
Sets the opam version
 | 
| with_os [OpamFile.OPAM] | |
| with_packages [OpamFile.Comp] | |
| with_patches [OpamFile.Comp] | |
| with_patches [OpamFile.OPAM] | 
Construct as  patches | 
| with_post_messages [OpamFile.OPAM] | |
| with_remove [OpamFile.OPAM] | 
Construct as  remove | 
| with_repositories [OpamFile.Config] | 
Repository updates
 | 
| with_solver [OpamFile.Config] | |
| with_src [OpamFile.Comp] | |
| with_substs [OpamFile.OPAM] | 
Construct as  substs | 
| with_switch [OpamFile.Config] | 
OCaml switch updates
 | 
| with_switch_backup [OpamClient] | 
Loads state with  command, and callsfon it. | 
| with_syntax [OpamFile.OPAM] | 
Replace the  syntaxfield of the given OPAM file. | 
| with_text [OpamProcess.Job] | 
Sets and overrides text of the underlying commands
 | 
| with_tmp_dir [OpamSystem] | with_tmp_dir fnexecutesfnin a tempory directory | 
| with_tmp_dir [OpamFilename] | 
Execute a function in a temp directory
 | 
| with_tmp_dir_job [OpamSystem] | 
Runs a job with a temp dir that is cleaned up afterwards
 | 
| with_tmp_dir_job [OpamFilename] | 
Provide an automatically cleaned up temp directory to a job
 | 
| with_version [OpamFile.OPAM] | 
construct as  version | 
| with_version_opt [OpamFile.OPAM] | |
| write [OpamSystem] | write filename contentswritecontentstofilename | 
| write [OpamFilename] | 
Removes everything in  filenameif existed, then writecontentsinstead. | 
| write [OpamFile.IO_FILE] | 
Write some contents to a file
 | 
| write_to_channel [OpamFile.IO_FILE] | 
Write to channel.
 | 
| Y | |
| yes [OpamGlobals] |