Dune

https://dune.readthedocs.io/en/stable/
Admin
Dune is a build system for OCaml projects, enabling the creation of executables, libraries, and the...
Tokens:109,966
Snippets:1,777
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Define an install stanza for an executable

Source: https://dune.readthedocs.io/en/stable/reference/dune/executable.html

Example of how to install an executable under a public name.

```dune
(install
 (section bin)
 (files (<name>.exe as <public-name>)))
```

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

### Install ppx_deriving

Source: https://dune.readthedocs.io/en/stable/tutorials/developing-with-dune/using-ppx.html

Install the required ppx_deriving package via opam.

```bash
opam install ppx_deriving.5.2.1
```

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

### Build and Run Example

Source: https://dune.readthedocs.io/en/stable/sites.html

Commands to build and execute the application with plugins.

```bash
$ dune build @install && dune exec ./app.exe
Registration of Plugin1
Main app starts...
Plugin1 is doing something...
```

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

### Install files to a site

Source: https://dune.readthedocs.io/en/stable/sites.html

Use the install stanza to place files into a defined site directory.

```dune
(install
 (section (site (mygui themes)))
 (files
  (layout.css as default/layout.css)
  (ok.png  as default/ok.png)
  (ko.png  as default/ko.png)))
```

```dune
(install
 (section (site mygui themes))
 (files
  (layout.css as material/layout.css)
  (ok.png  as material/ok.png)
  (ko.png  as material/ko.png)))
```

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

### Install Packages Manually

Source: https://dune.readthedocs.io/en/stable/usage.html

Use the install command to manually install packages when not using opam.

```bash
$ dune install [PACKAGE]...
```

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

### Install js_of_ocaml-compiler

Source: https://dune.readthedocs.io/en/stable/jsoo.html

Install the compiler using opam.

```bash
$ opam install js_of_ocaml-compiler
```

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

### Install a source directory

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Installs the contents of a source directory into the documentation section.

```dune
(install
 (section doc)
 (source_trees manual))
```

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

### Module Group Interface File Structure

Source: https://dune.readthedocs.io/en/stable/reference/dune/include_subdirs.html

Example file structure for accessing sub-modules in a qualified include_subdirs setup.

```text
dune
app.ml
sub
└── other.ml
```

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

### Install with Custom Destination

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Uses the 'as' keyword to rename or relocate a file during the installation process.

```dune
(install
 (section share_root)
 (files   (mylib.el as emacs/site-lisp/mylib.el)))
```

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

### Example test comment format

Source: https://dune.readthedocs.io/en/stable/tests.html

An example of the comment-based test syntax used in the provided backend example.

```ocaml
(*TEST: assert (fact 5 = 120) *)
```

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

### Install Dune via Opam

Source: https://dune.readthedocs.io/en/stable/howto/install-dune.html

Install the Dune package into the current Opam switch.

```bash
$ opam install dune
```

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

### Example C Header File

Source: https://dune.readthedocs.io/en/stable/foreign-code.html

A sample C header file defining constants and function prototypes for binding.

```c
#define FOO_VERSION 1

int foo_init(void);

int foo_fnubar(char *);

void foo_exit(void);
```

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

### Install odoc

Source: https://dune.readthedocs.io/en/stable/documentation.html

Install the odoc tool via opam to enable documentation generation.

```bash
$ opam install odoc
```

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

### Install files using parent directory glob

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Demonstrates a deprecated pattern for installing files from parent directories.

```dune
(install
 (files (glob_files ../*.txt))
 (section share))
```

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

### Install Alcotest dependency

Source: https://dune.readthedocs.io/en/stable/tutorials/developing-with-dune/unit-tests.html

Install the required Alcotest version via opam.

```bash
opam install alcotest.1.7.0
```

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

### Configure documentation stanzas

Source: https://dune.readthedocs.io/en/stable/documentation.html

Examples of the (documentation) stanza for attaching .mld files to packages.

```lisp
(documentation)
```

```lisp
(documentation
 (package foo)
  (mld_files foo bar baz))
```

```lisp
(documentation
 (mld_files :standard \ wip))
```

```lisp
(documentation
 (files
  (glob_files_rec
   (doc/* with_prefix .))))
```

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

### Install development dependencies

Source: https://dune.readthedocs.io/en/stable/hacking.html

Installs only the dependencies required for running tests, as defined in the opam file.

```bash
make dev-deps
```

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

### Install multiple source directories

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Specifies multiple source directories to be installed into the documentation section.

```dune
(install
 (section doc)
 (source_trees manual examples))
```

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

### Install a source directory with custom destination

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Uses the as keyword to install directory contents directly into the target path.

```dune
(install
 (section doc)
 (source_trees (manual as .)))
```

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

### Example source tree structure

Source: https://dune.readthedocs.io/en/stable/melange.html

Example of a project structure containing a melange.emit stanza and a library with melange mode.

```text
├── dune # (melange.emit (target output) (libraries lib))
├── app.ml
└── lib
    ├── dune # (library (name lib) (modes melange))
    └── helper.ml
```

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

### Basic Install Stanza

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Defines a standard installation of a file into a specific package section.

```dune
(install
 (files hello.txt)
 (section share)
 (package mypackage))
```

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

### Verify Dune Installation

Source: https://dune.readthedocs.io/en/stable/howto/install-dune.html

Confirm that Dune is correctly installed by checking its version.

```bash
$ dune --version
3.12.1
```

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

### Setting up an MDX action

Source: https://dune.readthedocs.io/en/stable/explanation/tour/rule-generation.html

Complex rule setup involving action builders, environment variables, and dynamic dependencies.

```OCaml
let mdx_action ~loc:_ =
  let open Action_builder.With_targets.O in
  let mdx_input_dependencies = (* ... *) in
  let executable, command_line = (* ... *) in
  let deps, sandbox = (* ... *) in
  let+ action =
    Action_builder.with_no_targets deps
    >>> Action_builder.with_no_targets
          (Action_builder.env_var "MDX_RUN_NON_DETERMINISTIC")
    >>> Action_builder.with_no_targets
          (Action_builder.map mdx_input_dependencies ~f:(fun d -> (), d)
           |> Action_builder.dyn_deps)
    >>> Command.run_dyn_prog
          ~dir:(Path.build dir)
          ~stdout_to:files.corrected
          executable
          command_line
  and+ locks =
    Expander.expand_locks expander stanza.locks |> Action_builder.with_no_targets
  in
  Action.Full.add_locks locks action |> Action.Full.add_sandbox sandbox
in
Super_context.add_rule sctx ~loc ~dir (mdx_action ~loc)
```

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

### Launch utop REPL

Source: https://dune.readthedocs.io/en/stable/usage.html

Commands to start a utop instance with local libraries or load modules via directives.

```bash
$ dune utop <dir> -- <args>
```

```ocaml
$ utop
# use_output "dune ocaml top-module path/to/module.ml";;
```

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

### Install Project Dependencies

Source: https://dune.readthedocs.io/en/stable/tutorials/developing-with-dune/introduction.html

Install specific versions of Dune and Menhir required for the project.

```bash
opam install dune.3.15.3 menhir.20231231
```

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

### Dune Directory Output Example

Source: https://dune.readthedocs.io/en/stable/usage.html

Example of the directory entry and exit messages printed by Dune during execution.

```text
$ dune runtest
Entering directory '/home/jdimino/code/dune'
...
Leaving directory '/home/jdimino/code/dune'
```

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

### Install Sherlodoc

Source: https://dune.readthedocs.io/en/stable/documentation.html

Install Sherlodoc to enable search functionality in generated HTML documentation.

```bash
$ opam install sherlodoc
```

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

### Generate install file list via rule

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Generate an S-expression file containing a list of files to be installed using a rule.

```dune
(rule
 (deps (source_tree resources))
 (action
  (with-stdout-to foo.sexp
  (system "echo '(' resources/* ')'"))))
```

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

### Install Melange via opam

Source: https://dune.readthedocs.io/en/stable/melange.html

Use the opam package manager to install the Melange compiler.

```bash
$ opam install melange
```

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

### Action Directory Context Example

Source: https://dune.readthedocs.io/en/stable/reference/actions/index.html

Demonstrates how variable expansion behaves relative to the current working directory of the executed DSL.

```dune
(action (chdir ../../.. (echo %{dep:dune})))
```

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

### Build dune.install with bootstrap Dune

Source: https://dune.readthedocs.io/en/stable/explanation/bootstrap.html

Command to generate the installation file using the bootstrap executable.

```bash
$ ./_boot/dune.exe build dune.install --release --profile dune-bootstrap
```

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

### Install Developer Tools

Source: https://dune.readthedocs.io/en/stable/reference/dune-tools.html

Pre-install developer tools to resolve dependencies and build them without immediate execution.

```console
$ dune tools install <tool>
```

```console
$ dune tools install ocamlformat
$ dune tools install ocamllsp
```

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

### Declare a Library and Corresponding Package

Source: https://dune.readthedocs.io/en/stable/howto/opam-file-generation.html

Example of a library definition and its corresponding package dependency declaration for a new project.

```dune
(library
 (public_name frobnitz)
 (libraries lwt fmt))
```

```dune
(package
 (name frobnitz)
 (depends lwt fmt))
```

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

### Typical dune-workspace file

Source: https://dune.readthedocs.io/en/stable/reference/dune-workspace/index.html

Example of a workspace file defining multiple opam switch contexts.

```lisp
(lang dune 3.14)
(context (opam (switch 4.08.1)))
(context (opam (switch 4.11.1)))
(context (opam (switch 4.14.2)))
```

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

### Install files using with_prefix

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Corrects the parent directory glob issue by using with_prefix to adjust the destination path.

```dune
(install
 (files (glob_files (../*.txt with_prefix .)))
 (section share))
```

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

### Registering a dependency rule

Source: https://dune.readthedocs.io/en/stable/explanation/tour/rule-generation.html

Example of calling Super_context.add_rule to generate a .mdx.deps file.

```OCaml
312let* () = Super_context.add_rule sctx ~loc ~dir (Deps.rule ~dir ~mdx_prog files)
```

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

### Cram test command

Source: https://dune.readthedocs.io/en/stable/tutorials/developing-with-dune/structure.html

Example of a cram test command; requires two spaces at the start of the line.

```text
  $ calc -e '1+2'
```

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

### Configure watch mode

Source: https://dune.readthedocs.io/en/stable/usage.html

Example of running a build in watch mode and defining a custom alias in a dune file.

```bash
$ dune build --watch -alias start/build
```

```lisp
(alias
 (name build)
 (deps (alias_rec %{project_root}/runtest)))
```

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

### Navigate and build the project

Source: https://dune.readthedocs.io/en/stable/quick-start.html

Standard commands to enter the project directory and trigger the build process.

```bash
$ cd project_name
```

```bash
$ dune build
```

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

### Accessing Bundled Resources

Source: https://dune.readthedocs.io/en/stable/howto/bundle.html

Example of accessing the generated module and variable within OCaml code.

```ocaml
let () = Printf.printf "%s" Css.css
```

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

### Hello World implementation with Core

Source: https://dune.readthedocs.io/en/stable/quick-start.html

A simple OCaml program using Core's Sexp module.

```ocaml
open Core

let () =
  Sexp.to_string_hum [%sexp ([3;4;5] : int list)]
  |> print_endline
```

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

### Initialize a Library

Source: https://dune.readthedocs.io/en/stable/usage.html

Creates a library directory and configures the corresponding dune file.

```bash
$ dune init lib mylib src --libs core --inline-tests --public
```

```lisp
(library
 (public_name mylib)
 (inline_tests)
 (name mylib)
 (libraries core)
 (preprocess
  (pps ppx_inline_tests)))
```

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

### Define a simple Rocq project

Source: https://dune.readthedocs.io/en/stable/rocq.html

Basic setup requiring a dune-project file with the rocq language enabled and a rocq.theory stanza.

```dune
(lang dune 3.24)
(using rocq 0.14)
```

```dune
(rocq.theory
 (name myTheory))
```

```coq
(** This is my def *)
Definition mydef := nat.
```

```text
.
├── A.v
├── _build
│   ├── default
│   │   ├── A.glob
│   │   ├── A.v
│   │   └── A.vo
│   └── log
├── dune
└── dune-project
```

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

### Create implementation directory

Source: https://dune.readthedocs.io/en/stable/tutorials/oxcaml-parameterized-library/index.html

Initialize the directory structure for the library implementation.

```bash
mkdir impl
```

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

### Install wasm_of_ocaml compiler

Source: https://dune.readthedocs.io/en/stable/wasmoo.html

Use opam to install the compiler package.

```bash
$ opam install wasm_of_ocaml-compiler
```

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

### Build and Execute Program

Source: https://dune.readthedocs.io/en/stable/howto/override-default-entrypoint.html

Commands to build the project and verify the custom entry point execution.

```bash
$ dune build
$ _build/default/hello.exe
Doing stuff before calling the OCaml runtime
Hello, world!
```

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

### Install cmdliner dependency

Source: https://dune.readthedocs.io/en/stable/tutorials/developing-with-dune/structure.html

Install the required cmdliner package via opam.

```bash
opam install cmdliner.1.3.0
```

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

### Access Help for Init Commands

Source: https://dune.readthedocs.io/en/stable/usage.html

Displays manual page information for the init subcommand.

```bash
dune init --help
```

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

### Initialize a library project

Source: https://dune.readthedocs.io/en/stable/quick-start.html

Creates a new project directory structure configured for building an OCaml library.

```bash
$ dune init proj --kind=lib project_name
```

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

### Initialize Components in Specific Paths

Source: https://dune.readthedocs.io/en/stable/usage.html

Specifies a target directory for component initialization.

```bash
$ dune init proj my_proj .
```

```bash
$ dune init proj my_proj path/to/my/project
```

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

### Build and execute the project

Source: https://dune.readthedocs.io/en/stable/tutorials/dune-package-management/setup.html

Commands to trigger the build process and execute the resulting binary.

```bash
dune build
```

```bash
$ dune exec ./test.exe
Hello, OCaml, Rust!
```

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

### Configure included directories

Source: https://dune.readthedocs.io/en/stable/reference/dune/dirs.html

Examples of using the dirs stanza to include or exclude directories using standard sets and globs.

```dune
(dirs *) ;; include all directories
(dirs :standard \ ocaml) ;; include all dirs except ocaml
(dirs :standard \ test* foo*) ;; exclude all dirs that start with test or foo
```

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

### Error Reporting Example

Source: https://dune.readthedocs.io/en/stable/reference/actions/index.html

Example of how an error in a generated file is reported by the compiler.

```text
File "blah.ml", line 42, characters 5-10:
Error: ...
```

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

### Initialize and promote generated rules

Source: https://dune.readthedocs.io/en/stable/howto/rule-generation.html

Commands to initialize the generated file and promote it to the source repository.

```bash
$ touch dune.inc
$ dune runtest
+ (rule
+  (with-stdout-to a.gen
+   (run %{bin:tool} a.input)))
+
+ (rule
+  (alias runtest)
+  (action
+   (diff a.output a.gen)))
$ dune promote dune.inc
$ git add dune.inc
```

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

### Build Documentation Commands

Source: https://dune.readthedocs.io/en/stable/hacking.html

Commands to build the project documentation using make.

```bash
$ make doc
```

```bash
$ make livedoc
```

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

### Implement a concurrent Hello World using Lwt

Source: https://dune.readthedocs.io/en/stable/quick-start.html

Use Lwt_main.run to execute concurrent I/O operations.

```ocaml
Lwt_main.run (Lwt_io.printf "Hello, world!\n")
```

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

### Equivalent modes configurations

Source: https://dune.readthedocs.io/en/stable/reference/dune/executable.html

Demonstrates equivalent ways to specify build modes using shorthand and explicit best-mode syntax.

```dune
(modes (exe object shared_object))
(modes ((best exe)
        (best object)
        (best shared_object)))
```

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

### Build and execute project

Source: https://dune.readthedocs.io/en/stable/tutorials/dune-package-management/dependencies.html

Commands to trigger the dependency solver and run the resulting executable.

```bash
$ dune build
```

```bash
$ dune exec ./test.exe
Hello, OCaml, Rust!
```

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

### Use globs in install stanza

Source: https://dune.readthedocs.io/en/stable/reference/dune/install.html

Specify files to install using glob_files and glob_files_rec patterns.

```dune
(install
 (files
  (glob_files style/*.css)
  (glob_files_rec content/*.html))
 (section share))
```

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

### Initialize an executable project

Source: https://dune.readthedocs.io/en/stable/quick-start.html

Creates a new project directory structure configured for building an executable.

```bash
$ dune init proj project_name
```

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

### ThreadSanitizer output example

Source: https://dune.readthedocs.io/en/stable/howto/use-multiple-build-contexts.html

Example output from a binary built with ThreadSanitizer detecting a data race.

```text
WARNING: ThreadSanitizer: data race (pid=1662846)
  Write of size 8 at 0x7fa28ecffa58 by main thread (mutexes: write M78):
    #0 camlDune__exe__Tsan_check.inc_272 <null> (tsan_check.exe+0x483e2)
    #1 camlDune__exe__Tsan_check.entry <null> (tsan_check.exe+0x484df)
    #2 caml_program <null> (tsan_check.exe+0x460a9)
    #3 caml_start_program <null> (tsan_check.exe+0xdca47)
    #4 caml_startup_common runtime/startup_nat.c:132 (tsan_check.exe+0xdc1f0)
    #5 caml_startup_common runtime/startup_nat.c:88 (tsan_check.exe+0xdc1f0)
    #6 caml_startup_exn runtime/startup_nat.c:139 (tsan_check.exe+0xdc29b)
    #7 caml_startup runtime/startup_nat.c:144 (tsan_check.exe+0xdc29b)
    #8 caml_main runtime/startup_nat.c:151 (tsan_check.exe+0xdc29b)
    #9 main runtime/main.c:37 (tsan_check.exe+0x45bf9)

  Previous write of size 8 at 0x7fa28ecffa58 by thread T1 (mutexes: write M83):
    #0 camlDune__exe__Tsan_check.inc_272 <null> (tsan_check.exe+0x483e2)
    #1 camlStdlib__Domain.body_735 <null> (tsan_check.exe+0x7b8ef)
    #2 caml_start_program <null> (tsan_check.exe+0xdca47)
    #3 caml_callback_exn runtime/callback.c:201 (tsan_check.exe+0x9ee53)
    #4 domain_thread_func runtime/domain.c:1215 (tsan_check.exe+0xa32d6)

  Mutex M78 (0x561082d9e728) created at:
    #0 pthread_mutex_init ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:1227 (libtsan.so.0+0x4bee1)
    #1 caml_plat_mutex_init runtime/platform.c:57 (tsan_check.exe+0xc9e6a)
    #2 caml_init_domains runtime/domain.c:943 (tsan_check.exe+0xa301e)
    #3 caml_init_gc runtime/gc_ctrl.c:353 (tsan_check.exe+0xaff83)
    #4 caml_startup_common runtime/startup_nat.c:111 (tsan_check.exe+0xdc0d7)
    #5 caml_startup_common runtime/startup_nat.c:88 (tsan_check.exe+0xdc0d7)
    #6 caml_startup_exn runtime/startup_nat.c:139 (tsan_check.exe+0xdc29b)
    #7 caml_startup runtime/startup_nat.c:144 (tsan_check.exe+0xdc29b)
    #8 caml_main runtime/startup_nat.c:151 (tsan_check.exe+0xdc29b)
    #9 main runtime/main.c:37 (tsan_check.exe+0x45bf9)

  Mutex M83 (0x561082d9e840) created at:
    #0 pthread_mutex_init ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:1227 (libtsan.so.0+0x4bee1)
    #1 caml_plat_mutex_init runtime/platform.c:57 (tsan_check.exe+0xc9e6a)
    #2 caml_init_domains runtime/domain.c:943 (tsan_check.exe+0xa301e)
    #3 caml_init_gc runtime/gc_ctrl.c:353 (tsan_check.exe+0xaff83)
    #4 caml_startup_common runtime/startup_nat.c:111 (tsan_check.exe+0xdc0d7)
    #5 caml_startup_common runtime/startup_nat.c:88 (tsan_check.exe+0xdc0d7)
    #6 caml_startup_exn runtime/startup_nat.c:139 (tsan_check.exe+0xdc29b)
    #7 caml_startup runtime/startup_nat.c:144 (tsan_check.exe+0xdc29b)
    #8 caml_main runtime/startup_nat.c:151 (tsan_check.exe+0xdc29b)
    #9 main runtime/main.c:37 (tsan_check.exe+0x45bf9)

  Thread T1 (tid=1662848, running) created by main thread at:
    #0 pthread_create ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:969 (libtsan.so.0+0x605b8)
    #1 caml_domain_spawn runtime/domain.c:1265 (tsan_check.exe+0xa499a)
    #2 caml_c_call <null> (tsan_check.exe+0xdc92b)
    #3 camlStdlib__Domain.spawn_730 <null> (tsan_check.exe+0x7b806)
    #4 camlDune__exe__Tsan_check.entry <null> (tsan_check.exe+0x484d1)
    #5 caml_program <null> (tsan_check.exe+0x460a9)
    #6 caml_start_program <null> (tsan_check.exe+0xdca47)
    #7 caml_startup_common runtime/startup_nat.c:132 (tsan_check.exe+0xdc1f0)
    #8 caml_startup_common runtime/startup_nat.c:88 (tsan_check.exe+0xdc1f0)
    #9 caml_startup_exn runtime/startup_nat.c:139 (tsan_check.exe+0xdc29b)
    #10 caml_startup runtime/startup_nat.c:144 (tsan_check.exe+0xdc29b)
    #11 caml_main runtime/startup_nat.c:151 (tsan_check.exe+0xdc29b)
    #12 main runtime/main.c:37 (tsan_check.exe+0x45bf9)

SUMMARY: ThreadSanitizer: data race (/path/to/directory/hello-tsan/_build/tsan/tsan_check.exe+0x483e2) in camlDune__exe__Tsan_check.inc_272
==================
x=5014663 expected=10000000
Fatal error: exception Assert_failure("tsan_check.ml", 19, 2)
ThreadSanitizer: reported 1 warnings
```

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

### Verify Opam Installation

Source: https://dune.readthedocs.io/en/stable/howto/install-dune.html

Check the installed version of Opam to ensure it meets the minimum requirement of 2.0.0.

```bash
$ opam --version
2.1.5
```

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

### Enable instrumentation via command line

Source: https://dune.readthedocs.io/en/stable/instrumentation.html

Activate instrumentation backends globally using the --instrument-with flag.

```bash
$ dune build --instrument-with <names>
```

```bash
$ dune build --instrument-with bisect_ppx,landmarks
```

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

### Build and execute project

Source: https://dune.readthedocs.io/en/stable/tutorials/dune-package-management/oxcaml.html

Commands to generate the lock directory and execute the compiled binary.

```bash
$ dune pkg lock
Solution for dune.lock

Dependencies common to all supported platforms:
- conf-autoconf.0.2
- conf-which.1
- ocaml.5.2.0
- ocaml-config.3
- ocaml-variants.5.2.0+ox

$ dune exec ./main.exe
...
43
```

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

### Hello World Implementation

Source: https://dune.readthedocs.io/en/stable/rocq.html

The OCaml source file providing the hello_world string.

```ml
let hello_world = "hello world!"
```

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

### Boolean Condition Example

Source: https://dune.readthedocs.io/en/stable/reference/boolean-language.html

Example of a Boolean expression checking for Flambda compiler support and OSX target.

```lisp
(and %{ocaml-config:flambda} (= %{ocaml-config:system} macosx))
```

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

### Implement Main Application Logic

Source: https://dune.readthedocs.io/en/stable/sites.html

The main application entry point that loads plugins and executes registered tasks.

```ocaml
(* load all the available plugins *)
let () = Sites.Plugins.Plugins.load_all ()

let () = print_endline "Main app starts..."
(* Execute the code registered by the plugins *)
let () = Queue.iter (fun f -> f ()) Registration.todo
```

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

### Install patdiff via opam

Source: https://dune.readthedocs.io/en/stable/concepts/promotion.html

Install the patdiff utility to improve the quality of diff output generated by Dune.

```bash
$ opam install patdiff
```

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

### Initialize a New Dune Project

Source: https://dune.readthedocs.io/en/stable/usage.html

Creates a new project directory with specified libraries and test configurations.

```bash
$ dune init proj myproj --libs base,cmdliner --inline-tests --ppx ppx_inline_test
```

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

### Configure a multi-theory project

Source: https://dune.readthedocs.io/en/stable/rocq.html

Demonstrates theory dependencies and directory structure using include_subdirs.

```text
.
├── A
│   ├── AA
│   │   └── aa.v
│   ├── AB
│   │   └── ab.v
│   └── dune
├── B
│   ├── b.v
│   └── dune
└── dune-project
```

```dune
; A/dune
(include_subdirs qualified)
(rocq.theory
 (name A))

; B/dune
(rocq.theory
 (name B)
 (theories A))
```

```coq
(* A/AA/aa.v is empty *)

(* A/AB/ab.v *)
Require Import AA.aa.

(* B/b.v *)
From A Require Import AB.ab.
```

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

### Rust Inline Test Example

Source: https://dune.readthedocs.io/en/stable/faq.html

An example of Rust's native inline testing syntax for private functions.

```rust
// define a private function
fn foo() { ... }

// test the function right next to its definition
#[test]
fn test_of_foo() { ... }
```

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

### Build a custom toplevel

Source: https://dune.readthedocs.io/en/stable/quick-start.html

Configure an executable as a custom toplevel and provide the entry point.

```dune
(executable
 (name       mytoplevel)
 (libraries  compiler-libs.toplevel mylib)
 (link_flags (-linkall))
 (modes      byte))
```

```ocaml
let () = exit (Topmain.main ())
```

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

### Install dependencies without building the project

Source: https://dune.readthedocs.io/en/stable/tutorials/dune-package-management/setup.html

Use the @pkg-install alias to install dependencies into the build folder without proceeding to build the project itself.

```bash
$ dune build @pkg-install
```

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

### Define a library in Dune

Source: https://dune.readthedocs.io/en/stable/faq.html

Example of a library definition in a dune file.

```dune
(library
 (public_name my_library)
 ...)
```

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

### Initialize and Load Nix Development Profiles

Source: https://dune.readthedocs.io/en/stable/hacking.html

Commands to initialize a Nix development profile to speed up environment loading and to load an existing profile.

```sh
nix develop --profile nix/profiles/dune
```

```sh
nix develop nix/profiles/dune
```

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

### Call library code in binary

Source: https://dune.readthedocs.io/en/stable/tutorials/oxcaml-parameterized-library/index.html

Example of invoking the library function from the executable.

```ocaml
let () = Lib.lib ()
```

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

### Specify maintainers in project_defaults

Source: https://dune.readthedocs.io/en/stable/reference/config/project_defaults.html

Example of setting default maintainers for a new project.

```dune
(project_defaults
 (maintainers
  "Jane Doe <jane.doe@example.com>"
  "John Doe <john.doe@example.com>"))
```

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

### Specify authors in project_defaults

Source: https://dune.readthedocs.io/en/stable/reference/config/project_defaults.html

Example of setting default authors for a new project.

```dune
(project_defaults
 (authors
  "Jane Doe <jane.doe@example.com>"
  "John Doe <john.doe@example.com>"))
```

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

### Define a rule with an executable

Source: https://dune.readthedocs.io/en/stable/cross-compilation.html

Example rule definition for an executable in a src/dune file.

```dune
(executable (name foo))
(rule (with-stdout-to blah (run ./foo.exe)))
```

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

### Enable a Dune language extension

Source: https://dune.readthedocs.io/en/stable/reference/dune-project/using.html

Example of enabling the mdx plugin with version 0.3.

```dune
(using mdx 0.3)
```

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

### Entry point for the calculator

Source: https://dune.readthedocs.io/en/stable/tutorials/developing-with-dune/structure.html

Main OCaml file to trigger the CLI logic.

```ocaml
let () = Calc.Cli.main ()
```

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

### Specify license in project_defaults

Source: https://dune.readthedocs.io/en/stable/reference/config/project_defaults.html

Example of setting a default license using an SPDX identifier.

```dune
(project_defaults
 (license "MIT"))
```

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

### Command Execution Output

Source: https://dune.readthedocs.io/en/stable/reference/actions/index.html

The shell command resulting from the basic rule execution example.

```bash
$ ocamllex -o blah.ml blah.mll
```

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

### Environment Variable Expansion

Source: https://dune.readthedocs.io/en/stable/concepts/variables.html

Example of accessing an environment variable with a default fallback value.

```text
%{env:BIN=/usr/bin}
```

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

### Create library directory

Source: https://dune.readthedocs.io/en/stable/tutorials/oxcaml-parameterized-library/index.html

Initialize the directory structure for the parameterized library.

```bash
mkdir lib
```

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

### Compose with installed theories

Source: https://dune.readthedocs.io/en/stable/rocq.html

Depend on external theories like mathcomp.ssreflect by specifying them in the theories field.

```dune
(rocq.theory
 (name my_mathcomp_theory)
 (theories mathcomp.ssreflect))
```

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

### Build and execute with specific contexts

Source: https://dune.readthedocs.io/en/stable/howto/use-multiple-build-contexts.html

Run the binary using either the default or the tsan context.

```bash
$ dune exec --context=default ./tsan_check.exe
$ dune exec --context=tsan ./tsan_check.exe
```

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

### Cram Test with Expected Output

Source: https://dune.readthedocs.io/en/stable/tests.html

Example of a test script showing the command and its expected output.

```cram
Simplest possible cram test
  $ echo "testing"
  testing
```

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

### Cram test output diff

Source: https://dune.readthedocs.io/en/stable/tutorials/developing-with-dune/structure.html

Example of the diff output generated by Dune when a test fails.

```text
   $ calc -e '1+2'
+  3
```

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

### Run tests and execute the program

Source: https://dune.readthedocs.io/en/stable/quick-start.html

Commands to execute the project's test suite and run the built executable.

```bash
$ dune test
```

```bash
$ dune exec project_name
```

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

### Conditional Flags Syntax

Source: https://dune.readthedocs.io/en/stable/reference/ordered-set-language.html

Example of the planned programmatic syntax for conditional flags in Dune files.

```lisp
(flags (if (>= %{ocaml_version} 4.08) ...))
```
Tokens:
Raw