dune.readthedocs.io Open in urlscan Pro
2606:4700::6811:2052  Public Scan

Form analysis
2 forms found in the DOM

GET search.html

<form id="rtd-search-form" class="wy-form" action="search.html" method="get">
  <input type="text" name="q" placeholder="Search docs" aria-label="Search docs">
  <input type="hidden" name="check_keywords" value="yes">
  <input type="hidden" name="area" value="default">
</form>

GET //readthedocs.org/projects/dune/search/

<form id="flyout-search-form" class="wy-form" target="_blank" action="//readthedocs.org/projects/dune/search/" method="get">
  <input type="text" name="q" aria-label="Dokumente durchsuchen" placeholder="Dokumente durchsuchen">
</form>

Text Content

Dune
stable


Getting Started and Core Concepts

 * Overview
 * Quickstart
 * Stanza Reference
 * Command-Line Interface

How-to Guides

 * How to Set up Automatic Formatting
 * How to Generate Opam Files from dune-project
 * Cross-Compilation
 * Dealing with Foreign Libraries
 * Generating Documentation
 * How to Load Additional Files at Runtime
 * Instrumentation
 * JavaScript Compilation With Js_of_ocaml
 * JavaScript Compilation With Melange
 * Toplevel Integration
 * Virtual Libraries & Variants
 * Writing and Running Tests

Reference Guides

 * Lexical Conventions
 * Ordered Set Language
 * Boolean Language
 * Predicate Language
 * Library Dependencies
 * User Actions
 * Foreign Sources, Archives, and Objects
 * Command Line Interface
 * Preprocessing Specification
 * Packages
 * Findlib Integration
 * Aliases
 * Scopes
 * Variables
 * Dependency Specification
 * OCaml Flags
 * Sandboxing
 * Locks
 * Diffing and Promotion
 * Package Specification
 * Coq
 * Dune Cache
 * Dune Libraries
 * Dune RPC

Explanations

 * How Preprocessing Works
 * The OCaml Ecosystem
 * How Dune integrates with opam

Advanced topics

 * Dynamic Loading of Packages with Findlib
 * Profiling Dune
 * Package Version
 * OCaml Syntax
 * Variables for Artifacts
 * Building an Ad Hoc .cmxs

Miscellaneous

 * FAQ
 * Goal of Dune
 * Working on the Dune Codebase

Dune
 * 
 * Welcome to Dune’s Documentation!
 * Edit on GitHub

--------------------------------------------------------------------------------


WELCOME TO DUNE’S DOCUMENTATION!¶

Getting Started and Core Concepts

 * Overview
   * Introduction
   * Terminology
   * Project Layout
   * History
 * Quickstart
   * Install Dune
   * Initializing Projects
     * Initializing an Executable
     * Initializing a Library
   * Building a Hello World Program From Scratch
   * Building a Hello World Program Using Lwt
   * Building a Hello World Program Using Core and Jane Street PPXs
   * Defining a Library Using Lwt and ocaml-re
   * Building a Hello World Program in Bytecode
   * Setting the OCaml Compilation Flags Globally
   * Using Cppo
     * Using the .cppo.ml Style Like the ocamlbuild Plugin
   * Defining a Library with C Stubs
   * Defining a Library with C Stubs using pkg-config
   * Using a Custom Code Generator
   * Defining Tests
   * Building a Custom Toplevel
 * Stanza Reference
   * dune-project
     * accept_alternative_dune_file_name
     * cram
     * dialect
     * executables_implicit_empty_intf
     * expand_aliases_in_sandbox
     * explicit_js_mode
     * formatting
     * generate_opam_files
     * implicit_transitive_deps
     * name
     * opam_file_location
     * package
     * subst
     * use_standard_c_and_cxx_flags
     * using
     * version
     * wrapped_executables
     * map_workspace_root
     * warnings
   * dune
     * alias
     * cinaps
     * copy_files
     * coq.theory
     * data_only_dirs
     * deprecated_library_name
     * dirs
     * documentation
     * env
     * executable
     * executables
     * external_variant
     * foreign_library
     * generate_sites_module
     * ignored_subdirs
     * include
     * include_subdirs
     * install
     * jbuild_version
     * library
     * mdx
     * menhir
     * ocamllex
     * ocamlyacc
     * plugin
     * rule
     * subdir
     * test
     * tests
     * toplevel
     * vendored_dirs
   * dune-workspace
     * env
     * config stanzas
     * context
     * profile
   * config
     * action_stderr_on_success
     * action_stdout_on_success
     * cache
     * cache-check-probability
     * cache-storage-mode
     * jobs
     * display
     * sandboxing_preference
     * terminal-persistence
 * Command-Line Interface
   * Initializing Components
     * Initializing a Project
     * Initializing an Executable
     * Initializing a Library
   * Finding the Root
     * Current Directory
     * Forcing the Root (for Scripts)
   * Interpretation of Targets
     * Resolution
     * Variables for Artifacts
   * Finding External Libraries
   * Running Tests
   * Watch Mode
   * Launching the Toplevel (REPL)
     * Requirements & Limitations
   * Restricting the Set of Packages
   * Distributing Projects
   * dune subst
   * Custom Build Directory
   * Installing a Package
     * Via opam
     * Manually
     * Destination Directory
     * Relocation Mode
   * Querying Merlin Configuration
     * Printing the Configuration
     * Printing an Approximated .merlin
     * Non-Standard Filenames
   * Running a Coq Toplevel

How-to Guides

 * How to Set up Automatic Formatting
   * Setting Up the Environment
   * Running the Formatters
   * Setting Up Your CI
 * How to Generate Opam Files from dune-project
   * Declaring Package Dependencies
     * For a New Package (No Existing Opam File)
     * For an Existing Package
     * General Notes and Tips
   * Generating Opam Files
 * Cross-Compilation
   * How Does it Work?
 * Dealing with Foreign Libraries
   * Adding C/C++ Stubs to an OCaml Library
     * Header Files
     * Installing Header Files
   * Stub Generation with Dune Ctypes
     * A Toy Example
     * Ctypes Field Reference
   * Foreign Build Sandboxing
     * Limitations
     * Real Example
 * Generating Documentation
   * Prerequisites
   * Writing Documentation
   * Building Documentation
     * Documentation Stanza: Examples
     * Package Entry Page
   * Passing Options to odoc
 * How to Load Additional Files at Runtime
   * Sites
     * Defining a Site
     * Adding Files to a Site
     * Getting the Locations of a Site at Runtime
     * Tests
     * Installation
     * Implementation Details
   * Plugins and Dynamic Loading of Packages
     * Example
       * Directory structure
       * Main Executable (C)
       * The Plugin “plugin1”
       * Running the Example
 * Instrumentation
   * Specifying What to Instrument
   * Enabling/Disabling Instrumentation
   * Declaring an Instrumentation Backend
 * JavaScript Compilation With Js_of_ocaml
   * Compiling to JS
   * Separate Compilation
 * JavaScript Compilation With Melange
   * Introduction
   * Simple Project
   * Libraries
   * melange.emit
   * Recommended Practices
     * Keep Bundles Small by Reducing the Number of melange.emit Stanzas
     * Faster Builds With subdir and dirs Stanzas
 * Toplevel Integration
 * Virtual Libraries & Variants
   * Virtual Library
   * Implementation
   * Variants
   * Default Implementation
   * Limitations
 * Writing and Running Tests
   * Running Tests
     * Running a Single Test
     * Running Tests in a Directory
   * Inline Tests
     * Inline Expectation Tests
     * Running a Subset of the Test Suite
     * Running Tests in Bytecode or JavaScript
     * Specifying Inline Test Dependencies
     * Passing Special Arguments to the Test Runner
     * Passing Special Arguments to the Test Executable
     * Using Additional Libraries in the Test Runner
     * Changing the Flags of the Linking Step of the Test Runner
     * Defining Your Own Inline Test Backend
       * Example of Backend
   * Custom Tests
     * Diffing the Result
   * Cram Tests
     * File Tests
     * Directory Tests
     * Test Options
     * Testing an OCaml Program
     * Sandboxing
     * Test Output Sanitation

Reference Guides

 * Lexical Conventions
   * Comments
   * Atoms
   * Strings
   * End of Line Strings
   * Lists
 * Ordered Set Language
 * Boolean Language
 * Predicate Language
 * Library Dependencies
   * Alternative Dependencies
   * Re-Exported Dependencies
 * User Actions
 * Foreign Sources, Archives, and Objects
   * Foreign Stubs
     * Mode-Dependent Stubs
   * Foreign Archives
   * Extra Objects
   * Flags
 * Command Line Interface
 * Preprocessing Specification
   * no_preprocessing
   * Preprocessing With Actions
   * Using PPX Rewriters
   * Arguments to PPX Rewriters
   * Future Syntax
   * Per-Module Preprocessing Specification
   * Preprocessor Dependencies
 * Packages
   * How Dune Knows About Packages
   * Generating Opam Files
   * What Dune Installs
 * Findlib Integration
   * How Dune Interprets META files
   * The Special Case of the OCaml Compiler
   * How Dune Generates META Files
 * Aliases
   * Model and Syntax
   * User-Defined Aliases
   * Built-In Aliases
     * @all
     * @check
     * @default
     * @doc
     * @doc-json
     * @doc-private
     * @fmt
     * @install
     * @lint
     * @runtest
 * Scopes
 * Variables
   * Expansion of Lists
 * Dependency Specification
   * Named Dependencies
   * Glob
 * OCaml Flags
 * Sandboxing
   * Per-Action Sandboxing Configuration
   * Global Sandboxing Configuration
 * Locks
 * Diffing and Promotion
   * Promotion
 * Package Specification
   * Declaring a Package
   * Attaching Elements to a Package
   * Sites of a Package
     * Libraries
     * Executables
     * Other Files
 * Coq
   * Introduction
   * coq.theory
     * Coq Dependencies
     * Coq Documentation
     * Recursive Qualification of Modules
     * How Dune Locates and Builds theories
     * Public and Private Theories
     * Limitations
     * Coq Language Version
     * Coq Language Version 1.0
   * coq.extraction
   * coq.pp
   * Examples of Coq Projects
     * Simple Project
     * Multi-Theory Project
     * Composing Projects
     * Composing With Installed Theories
     * Building Documentation
     * Coq Plugin Project
   * Running a Coq Toplevel
     * Limitations
   * Coq-Specific Variables
 * Dune Cache
   * Configuration
   * Cache Storage Mode
     * The hardlink Mode
     * The copy Mode
   * Trimming the Cache
   * Reproducibility
     * Reproducibility Check
     * Non-Reproducible Rules
 * Dune Libraries
   * Configurator
     * Usage
     * Upgrading From the Old Configurator
   * dune-build-info Library
   * (Experimental) Dune Action Plugin
 * Dune RPC
   * dune-rpc library
   * Connecting

Explanations

 * How Preprocessing Works
 * The OCaml Ecosystem
   * The OCaml Compiler Distribution: Compiling and Linking
   * Findlib: Metadata for Libraries
   * Opam: a Collection of Software Projects
   * Dune: Giving Structure to Your Source Tree
   * How Dune Integrates With the Ecosystem
   * Dune is Opinionated
 * How Dune integrates with opam
   * Substitution
   * Opam Variables
   * What -p Means
   * The Targets We’re Building
   * What Opam Expects From Dune

Advanced topics

 * Dynamic Loading of Packages with Findlib
 * Profiling Dune
 * Package Version
 * OCaml Syntax
 * Variables for Artifacts
 * Building an Ad Hoc .cmxs

Miscellaneous

 * FAQ
   * Why Do Many Dune Projects Contain a Makefile?
   * How to Add a Configure Step to a Dune Project
   * Can I Use topkg with Dune?
   * How Do I Publish My Packages with Dune?
   * Where Can I Find Some Examples of Projects Using Dune?
   * What is Jenga?
   * How to Make Warnings Non-Fatal
   * How to Turn Specific Errors into Warnings
   * How to Display the Output of Commands as They Run
   * How Can I Generate an mli File From an ml File
   * How Can I Build a Single Library?
   * Files and Directories Whose Names Begin with “.” (Period) are Ignored by
     source_tree
   * How Can I Write Inline Tests in a Package Without my Users Needing to
     Install ppx_inline_test?
 * Goal of Dune
   * Have Excellent Backward-Compatibility Properties
   * Have a Robust and Scalable Core
   * Remain a No-Brainer Dependency
   * Remain Accessible
   * Have Excellent Support for the OCaml Language
   * Be Extensible
 * Working on the Dune Codebase
   * Dependencies
   * Bootstrapping
   * Writing Tests
     * Guidelines
   * Setting Up Your Development Environment Using Nix
   * Releasing Dune
     * Major & Feature Releases
     * Point Releases
   * Adding Stanzas
     * Versioning
     * Experimental & Independent Extensions
   * Dune Rules
     * Creating Rules
     * Loading Rules
   * Documentation
     * Structure
     * ReStructured Text
     * Style
   * Vendoring
   * General Guidelines
     * Subjective Style Points
   * Benchmarking
     * Dune Bench
     * Inline Benchmarks
     * Build-Time Benchmarks
     * Melange Bench
     * Monorepo Benchmark
   * Formatting

Next

--------------------------------------------------------------------------------

Modernize your database with MongoDB Atlas, the leading developer data platform.
Ad by EthicalAds   ·   ℹ️

© Copyright 2017, Jérémie Dimino. Revision 7cbb0e72.

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: stable
Versionen latest stable Downloads PDF Epub Auf Read the Docs Projektstartseite
Erstellungsprozesse Downloads Auf GitHub Ansehen Suche


--------------------------------------------------------------------------------

Bereitgestellt von Read the Docs · Datenschutz-Bestimmungen