Contents
Part I An introduction to OCaml
Chapter 1 The core language
1.1 Basics
1.2 Data types
1.3 Functions as values
1.4 Records and variants
1.4.1 Record and variant disambiguation
1.5 Imperative features
1.6 Exceptions
1.7 Symbolic processing of expressions
1.8 Pretty-printing
1.9 Standalone OCaml programs
Chapter 2 The module system
2.1 Structures
2.2 Signatures
2.3 Functors
2.4 Functors and type abstraction
2.5 Modules and separate compilation
Chapter 3 Objects in OCaml
3.1 Classes and objects
3.2 Immediate objects
3.3 Reference to self
3.4 Initializers
3.5 Virtual methods
3.6 Private methods
3.7 Class interfaces
3.8 Inheritance
3.9 Multiple inheritance
3.10 Parameterized classes
3.11 Polymorphic methods
3.12 Using coercions
3.13 Functional objects
3.14 Cloning objects
3.15 Recursive classes
3.16 Binary methods
3.17 Friends
Chapter 4 Labels and variants
4.1 Labels
4.1.1 Optional arguments
4.1.2 Labels and type inference
4.1.3 Suggestions for labeling
4.2 Polymorphic variants
4.2.1 Weaknesses of polymorphic variants
Chapter 5 Polymorphism and its limitations
5.1 Weak polymorphism and mutation
5.1.1 Weakly polymorphic types
5.1.2 The value restriction
5.1.3 The relaxed value restriction
5.1.4 Variance and value restriction
5.1.5 Abstract data types
5.2 Polymorphic recursion
5.2.1 Explicitly polymorphic annotations
5.2.2 More examples
5.3 Higher-rank polymorphic functions
Chapter 6 Advanced examples with classes and modules
6.1 Extended example: bank accounts
6.2 Simple modules as classes
6.2.1 Strings
6.2.2 Hashtbl
6.2.3 Sets
6.3 The subject/observer pattern
Part II The OCaml language
Chapter 7 The OCaml language
7.1 Lexical conventions
7.2 Values
7.2.1 Base values
7.2.2 Tuples
7.2.3 Records
7.2.4 Arrays
7.2.5 Variant values
7.2.6 Polymorphic variants
7.2.7 Functions
7.2.8 Objects
7.3 Names
7.4 Type expressions
7.5 Constants
7.6 Patterns
7.7 Expressions
7.7.1 Basic expressions
7.7.2 Control structures
7.7.3 Operations on data structures
7.7.4 Operators
7.7.5 Objects
7.7.6 Coercions
7.7.7 Other
7.8 Type and exception definitions
7.8.1 Type definitions
7.8.2 Exception definitions
7.9 Classes
7.9.1 Class types
7.9.2 Class expressions
7.9.3 Class definitions
7.9.4 Class specifications
7.9.5 Class type definitions
7.10 Module types (module specifications)
7.10.1 Simple module types
7.10.2 Signatures
7.10.3 Functor types
7.10.4 The
with
operator
7.11 Module expressions (module implementations)
7.11.1 Simple module expressions
7.11.2 Structures
7.11.3 Functors
7.12 Compilation units
Chapter 8 Language extensions
8.1 Integer literals for types
int32
,
int64
and
nativeint
8.2 Recursive definitions of values
8.3 Lazy patterns
8.4 Recursive modules
8.5 Private types
8.5.1 Private variant and record types
8.5.2 Private type abbreviations
8.5.3 Private row types
8.6 Local opens for patterns
8.7 Object copy short notations
8.8 Locally abstract types
8.9 First-class modules
8.10 Recovering the type of a module
8.11 Substituting inside a signature
8.12 Type-level module aliases
8.13 Overriding in open statements
8.14 Generalized algebraic datatypes
8.15 Syntax for Bigarray access
8.16 Attributes
8.16.1 Built-in attributes
8.17 Extension nodes
8.17.1 Built-in extension nodes
8.18 Quoted strings
8.19 Exception cases in pattern matching
8.20 Extensible variant types
8.20.1 Private extensible variant types
8.21 Generative functors
8.22 Extension-only syntax
8.22.1 Extension operators
8.22.2 Extension literals
8.23 Inline records
8.24 Local exceptions
8.25 Documentation comments
8.25.1 Floating comments
8.25.2 Item comments
8.25.3 Label comments
8.26 Extended indexing operators
8.27 Empty variant types
Part III The OCaml tools
Chapter 9 Batch compilation (ocamlc)
9.1 Overview of the compiler
9.2 Options
9.3 Modules and the file system
9.4 Common errors
9.5 Warning reference
9.5.1 Warning 9: missing fields in a record pattern
9.5.2 Warning 52: fragile constant pattern
9.5.3 Warning 57: Ambiguous or-pattern variables under guard
Chapter 10 The toplevel system or REPL (ocaml)
10.1 Options
10.2 Toplevel directives
10.3 The toplevel and the module system
10.4 Common errors
10.5 Building custom toplevel systems:
ocamlmktop
10.5.1 Options
10.6 The native toplevel:
ocamlnat
(experimental)
Chapter 11 The runtime system (ocamlrun)
11.1 Overview
11.2 Options
11.3 Dynamic loading of shared libraries
11.4 Common errors
Chapter 12 Native-code compilation (ocamlopt)
12.1 Overview of the compiler
12.2 Options
12.3 Common errors
12.4 Running executables produced by ocamlopt
12.5 Compatibility with the bytecode compiler
Chapter 13 Lexer and parser generators (ocamllex, ocamlyacc)
13.1 Overview of
ocamllex
13.1.1 Options
13.2 Syntax of lexer definitions
13.2.1 Header and trailer
13.2.2 Naming regular expressions
13.2.3 Entry points
13.2.4 Regular expressions
13.2.5 Actions
13.2.6 Variables in regular expressions
13.2.7 Refill handlers
13.2.8 Reserved identifiers
13.3 Overview of
ocamlyacc
13.4 Syntax of grammar definitions
13.4.1 Header and trailer
13.4.2 Declarations
13.4.3 Rules
13.4.4 Error handling
13.5 Options
13.6 A complete example
13.7 Common errors
Chapter 14 Dependency generator (ocamldep)
14.1 Options
14.2 A typical Makefile
Chapter 15 The browser/editor (ocamlbrowser)
Chapter 16 The documentation generator (ocamldoc)
16.1 Usage
16.1.1 Invocation
16.1.2 Merging of module information
16.1.3 Coding rules
16.2 Syntax of documentation comments
16.2.1 Placement of documentation comments
16.2.2 The Stop special comment
16.2.3 Syntax of documentation comments
16.2.4 Text formatting
16.2.5 Documentation tags (@-tags)
16.3 Custom generators
16.3.1 The generator modules
16.3.2 Handling custom tags
16.4 Adding command line options
16.4.1 Compilation and usage
Chapter 17 The debugger (ocamldebug)
17.1 Compiling for debugging
17.2 Invocation
17.2.1 Starting the debugger
17.2.2 Initialization file
17.2.3 Exiting the debugger
17.3 Commands
17.3.1 Getting help
17.3.2 Accessing the debugger state
17.4 Executing a program
17.4.1 Events
17.4.2 Starting the debugged program
17.4.3 Running the program
17.4.4 Time travel
17.4.5 Killing the program
17.5 Breakpoints
17.6 The call stack
17.7 Examining variable values
17.8 Controlling the debugger
17.8.1 Setting the program name and arguments
17.8.2 How programs are loaded
17.8.3 Search path for files
17.8.4 Working directory
17.8.5 Turning reverse execution on and off
17.8.6 Communication between the debugger and the program
17.8.7 Fine-tuning the debugger
17.8.8 User-defined printers
17.9 Miscellaneous commands
17.10 Running the debugger under Emacs
Chapter 18 Profiling (ocamlprof)
18.1 Compiling for profiling
18.2 Profiling an execution
18.3 Printing profiling information
18.4 Time profiling
Chapter 19 The ocamlbuild compilation manager
Chapter 20 Interfacing C with OCaml
20.1 Overview and compilation information
20.1.1 Declaring primitives
20.1.2 Implementing primitives
20.1.3 Statically linking C code with OCaml code
20.1.4 Dynamically linking C code with OCaml code
20.1.5 Choosing between static linking and dynamic linking
20.1.6 Building standalone custom runtime systems
20.2 The
value
type
20.2.1 Integer values
20.2.2 Blocks
20.2.3 Pointers outside the heap
20.3 Representation of OCaml data types
20.3.1 Atomic types
20.3.2 Tuples and records
20.3.3 Arrays
20.3.4 Concrete data types
20.3.5 Objects
20.3.6 Polymorphic variants
20.4 Operations on values
20.4.1 Kind tests
20.4.2 Operations on integers
20.4.3 Accessing blocks
20.4.4 Allocating blocks
20.4.5 Raising exceptions
20.5 Living in harmony with the garbage collector
20.5.1 Simple interface
20.5.2 Low-level interface
20.6 A complete example
20.7 Advanced topic: callbacks from C to OCaml
20.7.1 Applying OCaml closures from C
20.7.2 Obtaining or registering OCaml closures for use in C functions
20.7.3 Registering OCaml exceptions for use in C functions
20.7.4 Main program in C
20.7.5 Embedding the OCaml code in the C code
20.8 Advanced example with callbacks
20.9 Advanced topic: custom blocks
20.9.1 The
struct custom_operations
20.9.2 Allocating custom blocks
20.9.3 Accessing custom blocks
20.9.4 Writing custom serialization and deserialization functions
20.9.5 Choosing identifiers
20.9.6 Finalized blocks
20.10 Advanced topic: Big arrays and the OCaml-C interface
20.10.1 Include file
20.10.2 Accessing an OCaml bigarray from C or Fortran
20.10.3 Wrapping a C or Fortran array as an OCaml big array
20.11 Advanced topic: cheaper C call
20.11.1 Passing unboxed values
20.11.2 Direct C call
20.11.3 Example: calling C library functions without indirection
20.12 Advanced topic: multithreading
20.12.1 Registering threads created from C
20.12.2 Parallel execution of long-running C code
20.13 Advanced topic: interfacing with Windows Unicode APIs
20.14 Building mixed C/OCaml libraries:
ocamlmklib
Chapter 21 Optimisation with Flambda
21.1 Overview
21.2 Command-line flags
21.2.1 Specification of optimisation parameters by round
21.3 Inlining
21.3.1 Classic inlining heuristic
21.3.2 Overview of “Flambda” inlining heuristics
21.3.3 Handling of specific language constructs
21.3.4 Inlining reports
21.3.5 Assessment of inlining benefit
21.3.6 Control of speculation
21.4 Specialisation
21.4.1 Assessment of specialisation benefit
21.5 Default settings of parameters
21.5.1 Settings at -O2 optimisation level
21.5.2 Settings at -O3 optimisation level
21.6 Manual control of inlining and specialisation
21.7 Simplification
21.8 Other code motion transformations
21.8.1 Lifting of constants
21.8.2 Lifting of toplevel let bindings
21.9 Unboxing transformations
21.9.1 Unboxing of closure variables
21.9.2 Unboxing of specialised arguments
21.9.3 Unboxing of closures
21.10 Removal of unused code and values
21.10.1 Removal of redundant let expressions
21.10.2 Removal of redundant program constructs
21.10.3 Removal of unused arguments
21.10.4 Removal of unused closure variables
21.11 Other code transformations
21.11.1 Transformation of non-escaping references into mutable variables
21.11.2 Substitution of closure variables for specialised arguments
21.12 Treatment of effects
21.13 Compilation of statically-allocated modules
21.14 Inhibition of optimisation
21.15 Use of unsafe operations
21.16 Glossary
Chapter 22 Memory profiling with Spacetime
22.1 Overview
22.2 How to use it
22.2.1 Building
22.2.2 Running
22.2.3 Analysis
22.3 Runtime overhead
22.4 For developers
Chapter 23 Fuzzing with afl-fuzz
23.1 Overview
23.2 Generating instrumentation
23.2.1 Advanced options
23.3 Example
Chapter 24 Compiler plugins
24.1 Overview
24.2 Basic example
Part IV The OCaml library
Chapter 25 The core library
25.1 Built-in types and predefined exceptions
25.2 Module
Pervasives
: the initially opened module
Chapter 26 The standard library
Chapter 27 The compiler front-end
Chapter 28 The unix library: Unix system calls
Chapter 29 The num library: arbitrary-precision rational arithmetic
Chapter 30 The str library: regular expressions and string processing
Chapter 31 The threads library
Chapter 32 The graphics library
Chapter 33 The dynlink library: dynamic loading and linking of object files
Chapter 34 The bigarray library
Part V Appendix
