This library provides minimal support for Canonical S-expressions. Canonical S-expressions are a binary encoding of S-expressions that is super simple and well suited for communication between programs.

This library only provides a few helpers for simple applications. If you need more advanced support, such as parsing from more fancy input sources, you should consider copying the code of this library given how simple parsing S-expressions in canonical form is.

To avoid a dependency on a particular S-expression library, the only module of this library is parameterised by the type of S-expressions.

Small implementation of a simple argv parser.

This extension provides a syntax for string interpolation.

This package implements an Ocaml language server implementation.

This package provides RE-based regular expressions support for Mparser.

Ppx-import is a syntax extension for importing declarations from interface files.

This package contains assert-like extension nodes that raise useful errors on failure.

This OCaml library provides an implementation of a mutable doubly-linked list with Lwt iterators.

This package is a ppx extension for easier implementation of conversion functions between almost identical types.

These libraries provides access to low-level compiler interfaces and the standard higher-level merlin protocol.

Eio_luv provides a cross-platform backend for Ocaml Eio's APIs using luv (libuv)

Provides an OCaml interface to operations that have dedicated hardware instructions on some micro-architectures, with default implementations using C stubs for all targets.

Uses the new result type defined in OCaml >= 4.03 while staying compatible with older version of OCaml should use the Result module defined in this library.

Crowbar is a library for testing code, combining QuickCheck-style property-based testing and the magical bug-finding powers of afl-fuzz.

MirageOS OS library for Xen targets, which handles the main loop and timers. It also provides the low level C startup code and C stubs required by the OCaml code.

Unix-related dependencies for things like system calls and threads. Using these, it hooks the Async_kernel scheduler up to either epoll or select, depending on availability, and manages a thread pool that blocking system calls run in.

Defines compile-time constants used in Jane Street libraries such as Base, Core, and Async. This package has an unstable interface; it is intended only to share configuration between different packages from Jane Street. Future updates may not be backward-compatible, and we do not recommend using this package directly.

Expect-test is a framework for writing tests in OCaml, similar to Cram. Expect-tests mimics the existing inline tests framework with the let%expect_test construct. The body of an expect-test can contain output-generating code, interleaved with %expect extension expressions to denote the expected output.

Bisect_ppx helps you test thoroughly. It is a small preprocessor that inserts instrumentation at places in your code, such as if-then-else and match expressions. After you run tests, Bisect_ppx gives a nice HTML report showing which places were visited and which were missed.

Usage is simple - add package bisect_ppx when building tests, run your tests, then run the Bisect_ppx report tool on the generated visitation files.

Ocp-indent is based on an approximate, tolerant OCaml parser and a simple stack machine. Presets and configuration options are available, with the possibility to set them project-wide. It supports the most common syntax extensions, and it is extensible for others.

This package includes:

• An indentor program, callable from the command-line or from within editors,

• Bindings for popular editors,

• A library that can be directly used by editor writers, or just for fault-tolerant and approximate parsing.

Lambda Soup is an HTML scraping library inspired by Python's Beautiful Soup. It provides lazy traversals from HTML nodes to their parents, children, siblings, etc., and to nodes matching CSS selectors. The traversals can be manipulated using standard functional combinators such as fold, filter, and map. The DOM tree is mutable. You can use Lambda Soup for automatic HTML rewriting in scripts. Lambda Soup rewrites its own ocamldoc page this way. A major goal of Lambda Soup is to be easy to use, including in interactive sessions, and to have a minimal learning curve. It is a very simple library.

The "findlib" library provides a scheme to manage reusable software components (packages), and includes tools that support this scheme. Packages are collections of OCaml modules for which metainformation can be stored. The packages are kept in the file system hierarchy, but with strict directory structure. The library contains functions to look the directory up that stores a package, to query metainformation about a package, and to retrieve dependency information about multiple packages. There is also a tool that allows the user to enter queries on the command-line. In order to simplify compilation and linkage, there are new frontends of the various OCaml compilers that can directly deal with packages.