The Caml Hump: Libraries :: Native OCaml libraries

This library is an extension of the Buffer library which is included in the standard OCaml distribution. Its interest is to allow to read buffers partially.

Interface to Google Adwords API. This API offers rapid, type-safe development, command line tools for doing common Adwords operations, interactive access to the API.

A library to help writing distributed programs. The library manages all the details relevant to process launching, channel creation, and network communication so as to let the programmer stick to the core of the problem. This allows to write programs that can be distributed on several machines in a concise way, with all the parallel aspects kept implicit (no synchronisation).

THis library contains a lot of the routines the author find needing all the time that aren't in the standard library (Especially string searching and manipulation), and some other odds and ends that are useful at times. Highlights include wildcard globbing, lots of string searching and manipulation routines, locale support, ~user-style path expansion, and more.

O'Caml ANSIColor is an O'Caml library for creating colorful text and other in effects in ANSI-compatible terminals. The code is staggeringly simple and the interface and implementation are both very roughly based on Term::ANSIColor.

A data structures library.

Library for Java .class file manipulation. Also a command-line [dis]assembler for Java.

BDBFS is a portable, user-level NFS fileserver implemented in OCaml. BDBFS stands for Berkeley DataBase File System: it stores files, metadata (directories, inodes, the superblock) as key:value pairs using the Berkeley Database (Berkeley DB) library.

A binary protocol generator.

Bindlib is a library and a camlp4 syntax extension for the OCaml language. It proposes a set of tools to manage data structures with bound and free variables. It includes fast substitution and management of variables names including renaming.

BioCaml aims to be a library of useful functions for bioinformatics, written in the Objective Caml (OCaml) language.

A bit vectors library.

A lexer/parser for turning files tagged for the British National Corpus into something usefully symbolically manipulated in OCaml.

A simple interface to the commercial Boom SMS (text message sending) service.

A functional programming library for for direct-mode BSP (Bulk Synchronous Parallel) algorithms.

An OCaml library managing dates and times.

two OCaml implementations of Dybvig, Sabry, Peyton-Jones' delimited continuation framework. The framework supports `static' ( shift/ reset) and `dynamic' ( prompt/ control, shift0, control0) delimited continuation operators with multiple, arbitrarily typed prompts.

A library for Objective Caml allowing SIMD parallel processing on PowerPC G4 processor using the Altivec vector processing unit.

CamlGI is a library to enable you to write CGI and FastCGI in OCaml. It is written 100% in OCaml so should run on many platforms. The library supports multiple simultaneous connections and request multiplexing while presenting an easy to use interface.

Camlhighlight provides syntax highlighting and pretty-printing facilities for displaying code samples in Ocsigen applications. The library works by parsing the output of Highlight, a widely available application supporting the most common programming and markup languages.

CamlIDL is a stub code generator and COM binding for Objective Caml.

A simple module for shell scripting in OCaml.

CamlPDF is a library for reading, writing and manipulating PDF files and data.

An Objective Caml library that provides easy access to compressed files in ZIP and GZIP format, as well as to Java JAR files.

Camomile is a comprehensive Unicode library for OCaml. Camomile provides Unicode character type, UTF-8, UTF-16, UTF-32 strings, conversion to/from about 200 encodings, collation and locale-sensitive case mappings, and more. The library is currently designed for Unicode Standard 3.2.

A strongly typed higher-order functional programming language for XML documents with an efficient type-based runtime implementation.

A small library to write CGI in Objective Caml.

An easy-to-use library for dynamically generating business-oriented data visualizations for the web.

This module implements compact integer sets, represented as a (custom) list of integer intervals. Usual set operations are provided. The advantage compared to ordered lists is that the actual size may be smaller than the cardinal of a set when many elements are contiguous. Most set operations are linear w.r.t. the size of the structure, not the cardinal of the set.

This package provides a syntax extension for easier manipulation of flat records, objects or tuples and conversions from/to CSV files for your favorite spreadsheet or plotting program.

'Concurrent Cell' is a library for multi-thread programming with CML(Concurrent ML) style synchronous message passing communications. The Threads library, a part of OCaml, realizes the CML style event value, but does not support shared variables like ivar and mvar. This library implements these variables without creating any new thread. This means that ivar and mvar are lightweight and GC target.

This library allows one to save configuration parameters (basic types, lists, user defined, etc.) into a file and load them. The configuration file is human readable, structured and allow (* *) comments.

An OCaml module for performing exact arithmetic on real numbers by representing them as continued fractions. It implements the well-known algorithm described by R.W. Gosper (see reference below). The continued fractions are lazy evaluated (eventually infinite) lists. Basic arithmetic operations as well as many transcendent functions are available.

coThreads is a concurrent programming library for OCaml. It enhances the Threads library of the standard OCaml distribution in two dimensions: coThreads implements the same API of the standard Threads library on different execution engines (process, netwoker(todo)), so that a single copy of source code can be compiled and deployed to different environments without modification; coThreads is also a super set of the standard Threads library, with extra components (STM etc.), functions (spawn etc.) and features (object-level compatibility etc.).

Symmetric cryptographic algorithms: Blowfish, DES, 3DES.

A library of cryptographic primitives for OCaml.

A full-featured charset and string library.

Some code to make it relatively easy to develop custom tree models using LablGTK (GTK+ 2.0 in OCaml). This means that you can have a tree structure coded naturally in OCaml and treat it more or less directly as a tree model, instead of having to shove values into a GTree.tree_store. There are some caveats as described in the README file.

A system for constructing functions automatically from type definitions.

A mutable, circular, doubly linked list library.

Dum is a library for inspecting the runtime representation of arbitrary Objective Caml values. Shared or cyclic data are detected and labelled. This guarantees that printing would always terminate. This makes it possible to print values such as closures, objects or exceptions in depth and without risk.

Dypgen is a GLR parser generator for Objective Caml, it is able to generate dynamically extensible parsers.

A small library (a module in fact) that is meant to make it easy to produce pretty-printed text. The data to be printed goes through a tree that carries all the information required for pretty-printing. After that, a single call to Easy_format.Pretty.to_stdout (for instance) outputs the indented result.

A group communication toolkit.

An Environment Interaction module for Objective Caml. It's useful if you need to create a local copy of the current environment for modification.

Equeue is a library that offers general purpose event queues and event queues for system events.

estring, which stands for `extended strings' is a library with a syntax extension allowing to see strings as lists of characters. It also define a new safe and extensible printf/scanf facility.

The ethread library has modules for read/write locks, barriers, and a simple thread-safe message queue that interacts with Unix.select so a thread can wait for I/O or a message at the same time.

Two small modules that implement extended synchronisations for O'Caml threads.

ExtLib is a project aiming at providing a complete - yet small - standard library for the OCaml programming langage. The purpose of this library is to add new functions to OCaml Standard Library modules, to modify some functions in order to get better performances or more safety (tail-recursive) but also to provide new modules which should be useful for the average OCaml programmer.

An efficient, imperative Fibonacci heap library, based on the pseudocode of Cormen, Leiserson, Rivest, and Stein. Aims to be practical and elegant.

A collection of utils to manipulate files following some UNIX convention.

Galax is an open-source implementation of XQuery 1.0, the W3C XML Query Language. Galax closely tracks the definition of XQuery 1.0 as specified by the W3C and also implements XPath 2.0, which is a subset of XQuery 1.0.

GenePool is a framework for writing evolutionary optimization algorithms in OCaml. This library is not a complete solution but rather is a generic skeleton which takes care of the plumbing and nuisances of optimization. You provide GenePool with functions that give meaning to fitness and reproduction and after a specified number of generation, GenePool returns an array of the best "genomes" it evolved.

Parsing of command line arguments (à la GNU GetOpt) for OCaml.

The facility that prints results and types of expressions evaluated at the top-level is now available anywhere in the program -- in bytecode- or natively compiled programs. Generic printing is a (perhaps unintentional) `side-effect' of MetaOCaml -- of the fact that a code value is not merely AST; the code value also captures the type and the type environment of variables and other values. Generic printing is a library that works with the unmodified MetaOCaml (which is _fully_ compatible with the regular OCaml).

A collection datastructure. Unordered insertion, uniformly random removal.

GraphPS is an Objective Caml module that allows generating PostScript graphic. Its interface is almost identical to that of the Graphics module of the distribution, so that it is easy to switch.

A pure OCaml library for performing calculations based on the Gregorian calendar.

HashSet is a hashed set library for Objective Caml. Buckets are ordered and the first element of a bucket is kept in a separate array, with occupation controlled by a bitvector.

HDCaml provides a framework for describing hardware structures in OCaml. Given a functional hardware description, HDCaml will produce a Verilog netlist for verification and implementation. HDCaml also has decent PSL support for assertion based verification.

Heaps, imperative and functional implementations.

HostIP is an OCaml module for looking up geolocation data from IP addresses. It uses the community HostIP project.

A generic library for browsing trees using hyperbolic geometry.

An ini file parser, in case you ever need to parse one of those little buggers.

"io" is an IO combinator library for safe I/O over strings and channels, in the style of "picklers" which can then be used with various backends to safely load and save data. Currently available backends include : human readable ASCII, binary and compressed binary. A type-independent command can convert between different representations. The representation for records and sum types is upwards compatible. Note that sharing and circular structures are not supported.

Reactive I/O Monad library implements I/O monad functions designed to facilitate writing of concurrent, reactive, single-threaded network application services in a functional style.

This library is a framework for concurrent, single-threaded Internet application services.

An OCaml library for the XMPP (better known as Jabber) instant messaging system.

Jane Street's alternative to the standard library.

JavaLib is a library that can fully parse Java .class file into OCaml data structure, thus enabling the OCaml programmer to extract informations from class files, to manipulate and to generate valid class files.

json-wheel is an OCaml implementation of the JSON data interchange format, which can be considered as a lightweight alternative to XML.

To use Kdialog from OCaml.

LEGO Mindstorm® is a versatile robotic construction kit. The central component is the programmable NXT brick to which one can connect up to three motors and various sensors. The brick can run programs directly uploaded to it or can be controlled via bluethooth or USB. This library allows you to communicate with — and drive — your NXT brick from OCaml programs through a bluetooth connection. The full LEGO® communication protocol (including all "direct commands") is supported. This library has been tested on Linux, Windows (without the fantom drivers installed) and Mac OSX.

A simple GUI for OCaml. It offers two kinds of widgets, to wit, buttons and an Emacs like mini-editor.The idea is to create a GUI with a very small footprint, that is easy to handle for final users, and productive for developers.

Machine Learning Library, a library containing structures and algorithms, simply usable from most of common languages.

A wrapper for the Objective Caml Hashtbl module that uses a Linked List to preserve the order in which the hash elements are added. It's similar in purpose to the Tie::IxHash module for Perl.

A message catalog system for localising text in OCaml programs. The approach taken is partly inspired by Perl's Locale::Maketext module. In an attempt to provide the flexibility needed to adapt sentence structure and morphology to numeric parameters in messages, the library uses a general-purpose template engine, CamlTemplate as a language for writing message templates.

A logger module for Objective Caml.

A small threaded line printer daemon whose primary goal was to enable the use of a windows-only printer, it should be easily modifiable for other purposes. A small module of pervasive-like functions for sockets on all platforms (including win9x) is bundled together.

A new API that uses higher-order functions and types to simplify the use of an embedded interpreter.

A system written in Caml and Maple to perform average-case complexity analysis of algorithms.

An Objective Caml library implementing part of the SMTP protocol.

Mathlib is a collection of hopefully-useful functions for working with floats, Complex numbers, and random numbers. It has the basic math functions added to the C99, trigonometric functions for complex numbers, the Mersenne Twister random number generator, and modules for generating random numbers in a variety of distributions.

Melt is a set of libraries and tools which allows you to program LaTeX documents using OCaml. This combines the typesetting power of LaTeX with the programming power of OCaml. It can be combined with Mlpost to include figures.

A module for runtime type checking in Ocaml. Memcheck is very similar to SafeUnmarshal but without a few of SafeUnmarshal's limitations. In particular, with Memcheck it only takes seconds to check a few megabytes instead of hours as with SafeUnmarshal.

A collection of various utilities for OCaml.

A library to produce PostScript documents.

mldiff is a program implementing the algorithm of "diff" (print differences between files) rewritten in ocaml. It contains also a module to compute differences between anything (not only strings).

A high-level interface to the Grace 2D plotting application. It makes extensive use of OCaml's labeled optional arguments, making the most common plotting operations quick and easy.

An Objective Caml library to produce PostScript images.

mlOscar is an OCaml library that facilitates the encoding/decoding of the AOL OSCAR protocol. Networking functionality is available to enable access to the AIM network.

A library containing functions to read or write mp3 tags.

This software implements the researches of the thesis of Peggy Cénac. Use the CGR to build a new family of tests of structure of sequences (i.i.d., markovian), empirically check the level and power of the tests and apply them on DNA sequences. Generalize the dinucleotide abundance profile to a CGR-based relative abundance profile and use this profile on DNA sequences to build taxonomy trees. Define CGR-trees, which are Digital Search Trees built from sequences, and check that the empirical longest branches, shortest branches and insertion level match the theorical results of the thesis.

Experimental client for HTTP/1.1 and telnet.

This is a small OCaml library for computing size of OCaml values. It computes count of words used for values, count of values' headers, maximal depth of values. There are functions to get size of values in bytes too.

Objsize is a small OCaml library for computing size of OCaml values. It computes count of words used for values, count of values' headers, maximal depth of values. There are functions to get size of values in bytes too.

This is a proper version of a SOAP client for OCaml, which uses CDuce (http://www.cduce.org/) to parse WSDL + XML Schema interface descriptions, turning them into SOAP client stubs.

OCaml-Reins is a data structure library for O'Caml that includes cursor based iterators, a collection of functors to minimize client-side boilerplate, a powerful on-line benchmarking system and Quickcheck style testing infrastructure.

This library can read and write CSV files, including all extensions used by Excel - eg. quotes, newlines, 8 bit characters in fields, "0 etc. The library comes with a handy command line tool called csvtool for handling CSV files from shell scripts.

Another print anything module.

This package contains the OCaml Interface to WordNet 2.1. It enables Ocaml programs to use the Wordnet dictionary for (english) word forms and meanings. This library directly parses the WordNet dictionary files, and does not depend on any other libraries. This library requires WordNet 2.1 to be installed (WordNet is available as a free download).

An implementation of the XML-RPC protocol.

Ocaml-ast-analyze should provide an abstraction of the structure required to build pr_*.cmo module for camlp4. The idea is to provide a simple way to build Ocaml abstract syntax tree analyzer. This should be particularly useful for string extraction of Ocaml source code.

A small module to benchmark running times of code. It supersedes an earlier version by Doug Bagley.

A small library of wrappers around standard library classes, to allow a somehow object-oriented use.

An OCaml small library for daemons (init, logging, configuration).

An advanced scheduler. The basics of this scheduler is to implement a wrapper around Unix.select in order to be able to wait for events on a socket and/or a given delay and execute a task when one of the waited events occured.

A high level module to access files through various protocols (local files, ftp, samba, etc). It provides high-level functions for that.

OCaml module to access files via ftp. It provides high-level functions for that.

A library inspired from perl's HTTP::Daemon that permits to write simple HTTP daemons in OCaml.

OCaml functions for manipulating mp3 id3 tags.

A quite simple program to do some basic routing over Open Streat Map maps. It parses an .osm.bz2 file, creates a compact data structure in memory (which is saved into a cache to speed up next searches), finds the OSM nodes closest to the source and goal points given as (latitude, longitude) couples, does the routing itself, prints it on the screen and saves it in .osm XML format (for example to load it into JOSM).

Packrat parser generator for OCaml.

A library providing functions to parse and print RSS 2.0 files. Comes with a graphical editor and a cameleon2 plugin.

A library which can be used to build web services using SOAP.

A small OCaml library providing functions to parse and print TODO lists in XML files.

Implements the Wu-Manber algorithm for string searching with errors (like in agrep).

LDAP bindings for ocaml.

This is an early release of a DBMS driver for Objective Caml. There is a generic interface that must be instantiated with a so-called low level driver. Currently, there is only a driver for the Adabas DBMS.

OcamlFd is an extension library for the OCaml language, providing miscellaneous utility functions involving UNIX file descriptors.

A graph library. Provides several graph data structures and several graph algorithms. Algorithms are written independently of the graph data structure (using functors).

The OCaml Network Application Environment is a project to provide a modular framework of libraries in Objective Caml to support the development of concurrent, single-thread-reactive network application servers with a functional programming style.

"Network extensions" library for OCamlNAE, which is a set of low-level interfaces designed for advanced network programming. The extension includes: extended socket interface (supports more options, and UDP with multicast), I/O event multiplexing (with Unix.select).

A collection of modules for the Objective Caml language which focus on application-level Internet protocols and conventions.

A parser generator for ordered context free grammars (OCFG) based on GLR (Generalized LR) parsing, also known as Tomita's parsing.

Odot is a small OCaml library to parse and print Graphviz dot files. It comes with an additional module defining a Lablgtk2 box to display such graphs, and handle mouse clicks on nodes.

OCaml Genetic Programming Framework.

A small library to demonstrate monadic programming in OCaml.

an implementation of the OAuth 1.0 protocol for OCaml, as well as an OCaml binding to Skydeck web API (providing access to your cell phone call log).

OOowrite lets you write OpenOffice or StarOffice .sxw files from OCaml programs.

A functional-reactive approach for developing distributed systems in Objective Caml. In Opis, a protocol description consists of a reactive function (called event function) describing the behavior of a distributed system node. The event functions in Opis are built from pure functions as building blocks, composed using the Arrow combinators. This facilitates reasoning about event functions both informally and using interactive provers. For example, this approach leads to simple termination arguments.

A tool for generating RPC bindings from OCaml signatures. Orpc works with the ONC RPC implementation in Ocamlnet; it is designed to be used in place of ocamlrpcgen. The advantage is that you can use familiar OCaml syntax, most OCaml data types, exceptions, and labeled/optional function arguments. In addition orpc can generate tracing/pretty-printing code from a signature, and it permits asynchronous clients and servers to be written using the Lwt threads library.

Ostap is an OCaml module to provide a set of parser combinators. The name of this library originates from Ostap Bender --- the central character of Ilya Ilf and Eugene Petrov's comedy "The Twelve Chairs". Bender is generally referred to as "The Great Combinator" since the word "combinator" in Russian also means "a swindler", "a sly man" etc. Additionally to the common set of parser combinators Ostap provides a camlp4 syntax extension pa_ostap.cmo to embed grammar expressions written in BNF-like style into OCaml code. Another feature of pa_ostap is that it allows to consider streams as objects and so makes integration of lexers and parsers simpler. Please have a look at the documentation for details.

Unit test framework for ocaml. It is based on HUnit, a unit testing framework for Haskell.

A module redefining common operations and raising an exception in case of overflow.

This is a tiny module combined with a camlp4 extension, which allows you to define polymorphic mappings, where the type of the data depends on the key.

Library for distributed computing in OCaml.

Password generator will return a password of configurable length. It can add special characters, digits, and capital letters to the password as well. The password is more human readable than a completely random secure password. The number of digits, special characters and capital letters is also configurable.

Efficient sets and maps over integers, from a paper by Chris Okasaki.

A persistent library for Ocaml. PersiL could help you to handle persistent data in your application (data which survive the end of the program).

A game engine to help creating more games more easily. The engine is written mainly in Ocaml with some XML and LUA.

Library for maintaining partially ordered maps.

OCaml stdlib replacement with a Haskellish flavour.

Okasaki's Purely Functional Datastructures in OCaml.

Polymorphic XML parser.

React is an OCaml module for functional reactive programming (FRP). It provides support to program with time varying values : applicative events and signals. React doesn't define any primitive event or signal, this lets the client chooses the concrete timeline.

Recursive is a tiny OCaml module that helps the programmer to manipulate cyclic structures (such as recursive types or finite automata) with maximal sharing and unique representation.

A library, entirely written in OCaml, for manipulation of regular expressions and string searching.

Library for automatically resizing contiguous memory (arrays and strings).

Resumable exceptions are the strict generalization of regular exceptions, which lets the exception raising form return a value and so the computation may continue. It's the exception handler that decides either to abort the exceptional computation or to resume it with a particular value. We show a conservative and elementary implementation of resumable exceptions in OCaml: the implementation is a self-contained 100% pure OCaml library.

RPC is a package supporting the Sun RPC protocol. RPC programs, procedures, clients, and servers can be dynamically represented and modified. Of course, there is also a classical RPC generator which generates functions doing the language mapping from XDR values to language values and vice versa.

Rtime is an OCaml module implementing timelines for React [1]. It manages time stamp events, delayed events and delayed signals along timelines. The client chooses the concrete timeline by providing an absolute notion of time. Running the timeline at the appropriate pace is left to the client.

A couple of files for turning basic XML documents (channels) into an XML stream.

Scampi (Simple CAml to MPI interface) is small library allowing Caml programs to make calls to MPI-1 communication routines. For now only a few calls are provided (basically, getting communicator size, rank and making synchronous and asynchronous send/receive of polymorphic data plus a couple of collective comm), but it is expected that subsequent versions will enlarge the set of provided bindings. This first version, however, effectivily allows building parallel Caml programs running in SPMD mode on a network of workstations for example.

A high-level combinatorial dataflow programming library based upon destructive lazy streams.

This library can be used to segment Newspaper style (english) text articles into sentences. It uses the Ocaml lexer with a simple set of lexical rules to classify those periods ('.') in the text that end sentences.

Library for automated conversion of OCaml-values to and from S-expressions.

SimpleSOAP is an early, experimental SOAP client for Objective CAML.

SOSS is an implementation of a SOAP server for OCaml. It is designed to allow a service, developed in OCaml, to be made available as a SOAP service with minimal effort.

Binary trees where often accessed items tend to be near the root.

Symbolic Parameterized Polyhedral Calculator.

An implementation of the Porter stemming algorithm for OCaml.

This is a user-space implementation of STM (Software Transactional Memory) library for OCaml. It's mainly inspired by the STM library of Haskell, with some exceptions due to the different nature of languages and different strategies of implementation.

Provides an ability to interactively edit/navigate arbitrary Ocaml data structures.

Timbuk is a collection of tools for achieving proofs of reachability over Term Rewriting Systems and for manipulating Tree Automata (bottom-up non-deterministic finite tree automata).

Tony is a simple XML parser and pretty printer for Objective Caml. While you would most likely use it as a library it comes for demonstration purposes as an application. Tony reads an XML file and pretty prints it nicely. The parser is implemented using Lex and Yacc, the pretty printer using Philip Wadler's pretty-printing algebra. Today more complete (and complex) XML parsers for OCaml exist; Tony is still useful if you want to cover the basic case.

Hides toplevel values whose name starts with an underscore.

Implementation of tries (maps over lists).

Ulex is a lexer generator for Unicode and OCaml.

Uuidm is an OCaml module implementing 128 bits universally unique identifiers version 3, 5 (name based with MD5, SHA-1 hashing) and 4 (random based) according to RFC 4122. Uuidm is made of a single, independent, module and distributed under the new BSD license.

An Ocaml implementation of extensible arrays. The implementation is functional, based on balanced trees (and on the code for Set and Map).

A runtime value printer for OCaml, extremely experimental at the moment, use at your own risk.

Wallace is a generic subtyping-constraint-handling library. It deals with constraint solving and simplification, and it is parameterized by the definition of a type algebra. Its goal is to serve as a plug-in component in the design of a constraint-based type-checker, regardless of the programming language being analyzed.

WDialog is an advanced system to create dialog-centric web applications.'

A weak hash table library for OCaml, with an interface compatible with the standard Hashtbl library.

Weblogs is an OCaml module for importing weblogs from Apache or IIS web servers.

To use Xdialog from OCaml.

XHTML is a O'Caml module for creating valid XHTML 1.1 (and XHTML 1.0) documents. The validity of the pages is guaranteed by the O'Caml type system. (NB: at the time of writing, forms support was not complete, only basic forms are implemented. Image maps are also not implemented yet.)

XML Light is a minimal XML parser & printer for OCaml. It provide functions to parse an XML document into an OCaml data structure, work with it, and print it back to an XML document. Since version 2, XML Light add also support for DTD and PCDATA.

Xmlm is an OCaml module providing streaming XML input/output. It aims at making XML processing robust and painless. The streaming interface can process documents without building an in-memory representation. It lets the programmer translate its data structures to XML documents and vice-versa. Functions are provided to easily transform arborescent data structures to/from XML documents.

XmlRpc-Light is an XmlRpc client written in OCaml. It requires Xml-Light and Ocamlnet.

XmlRPCServer is a server side implementation for the XmlRPC package developed by Shawn Wagner. This package provides methods to transform between OCaml data-types and their XmlRPC representation, and visa versa. In addition it provide the client side functionality which enables OCaml clients to call servers written in other languages using XmlRPC. However the current version of the package does not support writing the server side in OCaml, unless you do most of the work yourself.

This package implements the XPath recommendation; XPath is a simple query language for XML. A compact XPath expression can perform a relatively complex search on the document tree. XPath is used by XLink and XSLT. The package is modularized and functorial: the evaluator is a functor taking as argument an implementation of the XPath Data Model as defined in the recommendation. The package include a lightweight implementation, build from the Pxp document tree. A future version will include a Data Model implementation working directly on this document tree.

An unfunctorized version of Set and Map.

Thread-safe implementation of string searching/matching/splitting.

Yacclib is a small OCaml library to parse and print OCamlyacc .mly files. It can also print dot graphs from these files. It comes with a graphical editor for .mly files.

Yet Another C/C++ Front-End, which is an OCaml API to write style-preserving source-to-source transformations such as refactorings on C or C++ source code.

This toolkit offers a few fundamental structures useful for computational linguistics. It is implemented in Pidgin ML, which is a core subset of the Objective Caml programming language under the so-called revised syntax.