Search inside the OCaml documentation

1. Sets

   Sets With Custom Comparators

   e Insensitive String Set"). We can accomplish this by passing an ad-hoc module to the Set.Make function: Let's say we want to create a set of strings th [...] et module we created uses the built-in compare function provided by the String module. The Set.Make functor expects a module with two definitions: a t

   Data Structures

2. Maps

   Introduction

   StringMap , OCaml's toplevel displays the module's signature. Since it contains a large number of functions, the output copied here is shortened for brevi [...] es the keys' type to be used in the maps, and a function for comparing them. Note : The concept of a Map in this tutorial refers to a data structure that

   Data Structures

3. Maps

   Finding Entries in a Map

   ote that find_first_opt and find_last_opt return the key-value pair, not just the value. The functions find_first and find_last behave similarly, e [...] d find_last_opt if we want to use a predicate function: find_opt returns None find throws the Not_found exceptions When the searched key is absent f

   Data Structures

4. Maps

   Changing the Value Associated With a Key

   You should experiment with different update functions; several behaviors are possible. To change a key's associated value, use the update function. It takes a key, a map, and an update

   Data Structures

5. Maps

   Maps With Custom Key Types

   Note that our module has a type t and also a compare function. Now we can call the Map.Make functor to get [...] A type t exposing the type of the map's key A function compare : t -> t -> int

   Data Structures

6. Labelled and Optional Arguments

   Labelling Parameters

   sing the same name as label and parameter. Here is how range is used: lo and hi inside the function's body, as usual first and last when calling the function; these are the labels. The parameters of range are named Here is how to name parameters in a

   Introduction

7. Labelled and Optional Arguments

   Passing Labelled Arguments Using the Pipe Operator

   Let's modify the range function previously defined by adding an additional parameter step . Declaring a function's unlabelled argument as the first one simplifies reading the

   Introduction

8. Sequences

   Constructing Sequences

   tains a module for sequences called Seq . It contains Seq.int , which we implemented above. The function ints n looks as if building the infinite sequen [...] in_int . We can also construct sequences using functions. Here is how to build an infinite sequence of integers: Note: The second component of each Se

   Data Structures

9. Sequences

   Reading a File with Seq.Unfold

   ps it would be enlightening to illustrate the use of Seq.unfold by re-implementing the already seen function primes? Perhaps in an exercise rather than in the [...] accumulator, and also the fact that the producer function loops until it finds a new prime to yield, because Seq.unfold does not allow the producer to “ski

   Data Structures

10. Sequences

    Sequences for Conversions

    Similar functions are also provided for sets, maps, hash tables ( [...] , it is advised to expose to_seq and of_seq functions. Lists Arrays Strings Throughout the standard library, sequences are used as a bridge to

    Data Structures

11. Memory Representation of Values

    Polymorphic Variants

    ts with constructors thus use one word of memory more than normal variant constructors. The hash function is designed to give the same results on 32-bit an [...] integer value is determined by applying a hash function to the name of the variant. The hash

    Runtime & Compiler

12. Understanding the Garbage Collector

    Attaching Finalizer Functions to Values

    <div class="note"> OCaml's automatic memory management guarantees that a value will eventually be freed when it's no longer in use, either via the GC sweeping it or the program terminating. It'

    Runtime & Compiler

13. Lists

    List Searching

    elements for which the predicate is true, the second those for which it is false. The filter function again takes a predicate and tests it against ea [...] the list of all elements which test true: The function find returns the first element of a list matching a given predicate (a predicate is a testing

    Introduction

14. Arrays

    Introduction

    ch as: This tutorial aims to introduce the subject of arrays in OCaml and showcase the most useful functions and use cases. Despite these differences, many of the functions readily available on arrays are similar to the ones available for lists. Please refer to the List

    Data Structures

15. Arrays

    Creating Arrays

    Array.init generates an array of a given length by applying a function to each index of the array, starting at 0. The fo [...] array containing the first 5 even numbers using a function which doubles its argument: Alternatively, you can create an array using the Array.make

    Data Structures

16. Arrays

    Copying Part of an Array into Another Array

    tarting at index 1 into the last part of zeroes , starting at index 3 . We can also use this function to copy part of an array onto itself: This copie [...] hin the bounds of each array. The Array.blit function efficiently copies a contiguous part of an array into an array. Similar to the array.(x) <- y ope

    Data Structures

17. OCaml Programming Guidelines

    Factor out snippets of repeated code by defining them in separate functions

    Sharing code obtained in this way facilitates maintenance, since every correction or improvement automatically spreads throughout the program. Besides, the simple act of isolating and naming a sn

    Resources

18. OCaml Programming Guidelines

    Never copy-paste code when programming

    ten lines of code is repeated twenty times throughout the program. By contrast, if an auxiliary function defines those ten lines, it is fairly easy to see [...] find where those lines are used: simply where the function is called. If code is copy-pasted all over the place, then the program is more difficult to und

    Resources

19. OCaml Programming Guidelines

    Always give the same name to function arguments which have the same meaning

    If necessary, make this nomenclature explicit in a comment at the top of the file. If there are several arguments with the same meaning, then attach numeral suffixes to them.

    Resources

20. OCaml Programming Guidelines

    Local identifiers can be brief and should be reused from one function to another

    A tolerated exception to the recommendation not to use capitalisation to separate words within identifiers when interfacing with existing libraries which use this naming convention. This lets OCa

    Resources

21. OCaml Programming Guidelines

    Exceptions

    -> Handling all exceptions by try ... with _ -> is usually reserved for the program's main function. If you must catch every exception in order to [...] e system as possible. For example, every search function that fails should raise the predefined exception Not_found . Be careful to handle the exceptions

    Resources

22. OCaml Programming Guidelines

    How to Choose Between Classes and Modules

    Use modules when the data structures are fixed and their functionality is equally fixed or it's enough to add new functions in the programs which use them. Use conventional data structures (in particular, variant type

    Resources

23. OCaml Programming Guidelines

    Clarity of OCaml Code

    r programming paradigms): imperative programming (based on the notion of state and assignment), functional programming (based on the notion of function,

    Resources

24. OCaml Programming Guidelines

    Function application: the same rules as those in mathematics for usage of trigonometric functions

    In mathematics you write sin x to mean sin (x) . In the same way sin x + cos x means (sin x) + (cos x) not sin (x + (cos x)) . Use the same conventions in OCaml: write f x + g x to mean

    Resources

25. Error Handling

    Predefined Exceptions

    reexisting exceptions Raise custom exceptions When implementing a software component which exposes functions raising exceptions, a design decision must be [...] ones are intended to be raised by user-written functions: Although the last one doesn't look as an exception, it actually is. The standard library pr

    Guides

26. Error Handling

    Printing

    own exceptions: To print an exception, the module Printexc comes in handy. For instance, the function notify_user : (unit -> 'a) -> 'a below calls a function, and if it fails, prints the exception on stderr . If stack traces are enabled, this

    Guides

27. Error Handling

    Throwing Exceptions From option or result

    ons, pattern matching and raise must be used. From option to Invalid_argument exception, use function Option.get : From result to Invalid_argument exception, use functions Result.get_ok and Result.get_error : This is done by using the following

    Guides

28. Error Handling

    Conversion Between option and result

    From option to result , use function Option.to_result : From result to option , use function Result.to_option : This is done by using the following

    Guides

29. Calling Fortran Libraries

    Step 3: Compile the Shared Library

    This will create a shared object library called wrapper.so containing the fortran function and the wrapper function. The -lg2c option is required to provide the implementations of the built in fortran

    Tutorials

30. The Compiler Frontend: Parsing and Type Checking

    Which Comes First: The ml or the mli?

    ode by starting with an ml file and using the type inference to guide you as you build up your functions. The mli file can then be generated as described, and the exported functions documented.

    Runtime & Compiler

31. Options

    Exceptions vs Options

    dling for a longer discussion on error handling using options, exceptions, and other means. The function Sys.getenv : string -> string from the OCaml st [...] e variable is not defined. On the other hand, the function Sys.getenv_opt : string -> string option does the same, except it returns None if the variable

    Data Structures

32. Options

    Map Over an Option

    In the standard library, this is Option.map . Using pattern matching, it is possible to define functions, allowing to work with option values. Here is m [...] -> 'a option -> 'b option . It allows to apply a function to the wrapped value inside an option , if present:

    Data Structures

33. Modules

    Module Inclusion

    es a module Extlib.List that has everything the standard List module has, plus a new uncons function. In order to override the default List module [...] ib at the beginning. Let's say we feel that a function is missing from the List module, but we really want it as if it were part of it. In an extlib.

    Module System

34. Basic Data Types and Pattern Matching

    Byte Sequences

    rray . Operations on bytes values are provided by the Stdlib and the Bytes modules. Only the function Bytes.get allows direct access to the character [...] bytes literally, so they must be produced by a function. <!--CR Moved intro pp to after example, as it contains the definition. Perhaps a short intro se

    Introduction

35. Basic Data Types and Pattern Matching

    Lists

    ce with respect to lists: Operations on lists are provided by the List module. The List.append function concatenates two lists. It can be used as an oper [...] values they contain. Lists play a central role in functional programming, so they have a dedicated tutorial . As literals, lists are very much like arrays

    Introduction

36. Basic Data Types and Pattern Matching

    Tuples

    t associative . In the standard library, both are defined using pattern matching. Here is how a function extracts the third element of the product of four types: The predefined function fst returns the first element of a pair, while snd returns the second element of a pair. This

    Introduction

37. Basic Data Types and Pattern Matching

    Recursive Variants

    bol _ , which catches everything. It returns false on all data that is neither Array nor Object . Functions defined using pattern matching on recursive variants are often recursive too. This function checks if a name is present in a whole JSON tree: Both constructors Array and Object contain values of type json . This is the case for the following definition, which can be used to store J

    Introduction

38. Basic Data Types and Pattern Matching

    Revisiting Predefined Types

    In the end, the only type construction that does not reduce to a variant is the function arrow type. Pattern matching allows the inspection of values of any type, except functions. Even integers and floats can be seen as enumerated-like variant types, with many constructors an

    Introduction

39. Basic Data Types and Pattern Matching

    User-Defined Polymorphic Types

    ors. Here are the terms applicable to data types: In the OCaml community, as well as in the larger functional programming community, the word polymorphism [...] ssary to distinguish them. Here is how the map function can be defined in this type: It can be used to represent arbitrarily labelled binary trees. Assu

    Introduction

40. Functors

    Introduction

    his tutorial are available as a Git repo . As suggested by the name, a functor is almost like a function. However, while the inputs and outputs of functions are values, functors are between modules. A functor has a module as a parameter and returns a modu

    Module System

41. Preprocessors and PPXs

    Attributes and Derivers

    for the fields of a given record type. Example of derivers are: Derivers are great for generating functions that depend on the structure of a defined type [...] d a "deprecated" warning, or force/check that a function is inlined. The full list of attributes that the compiler uses is available in the manual .

    Advanced Topics

42. Preprocessors and PPXs

    Why PPXs Are Especially Useful in OCaml

    the type-checker on the produced value and the familiarity of writing HTML code. So any general function that depends on the type's structure must be [...] to_string : 'a -> string or print : 'a -> () function can exist in compiled binaries (in the toplevel, types are kept). Now that we know what a PPX is

    Advanced Topics

43. Mutability and Imperative Control Flow

    Byte Sequences

    char array . The former should always be preferred, except when array is required by polymorphic functions handling arrays. updatable strings that can't b [...] ces can be created from string values using the function Bytes.of_string . Individual elements in the sequence can be updated or read by their index using

    Introduction

44. Mutability and Imperative Control Flow

    Breaking Loops Using Exceptions

    d. When the ASCII Escape character is read, the Exit exception is thrown, which terminates the iteration and displays the REPL reply: - : unit = () . The following example uses the get_char function we defined earlier (in the section Example: get_char Function ). Throwing the Exit exception is a recommended way to immediately exit from a loop.

    Introduction

45. Mutability and Imperative Control Flow

    References Inside Closures

    nt value. Similarly, calling c2 () will update its own independent counter. First, we define a function named create_counter that takes no arguments. I [...] sing !counter . In the following example, the function create_counter returns a closure that “hides” a mutable reference counter . This closure cap

    Introduction

46. Mutability and Imperative Control Flow

    Bad: Side Effects Depending on Order of Evaluation

    itialising record fields. Here, it is illustrated on a tuple value: Since the evaluation order for function arguments in OCaml is not explicitly defined, the [...] rintf "%s %s %s" is applied to the results. The function id_print returns its input unchanged. However, it has a side effect: it first prints the string i

    Introduction

47. Monads

    The Monad Signature

    its second argument to the first. That requires taking the 'a value out of its box, applying the function to it, and returning the result. a boxed value, which has type 'a t , and a function that itself takes an unboxed value of type 'a as input and returns a boxed value of type '

    Data Structures

48. The Compiler Backend: Bytecode and Native code

    Where Did the Bytecode Instruction Set Come From?

    laid the theoretical basis for the implementation of an instruction set for a strictly evaluated functional language such as OCaml. The bytecode interpre [...] different model since it uses CPU registers for function calls instead of always passing arguments on the stack, as the bytecode interpreter does. The by

    Runtime & Compiler

49. The Compiler Backend: Bytecode and Native code

    Accessing Stdlib Modules from Within Core

    g polymorphic and monomorphic comparison, you may have noticed that we prepended the comparison functions with Stdlib . This is because the Core module [...] always recover any of the OCaml standard library functions by accessing them through the Stdlib module, as we did in our benchmark.

    Runtime & Compiler

50. Sets

    Introduction

    StringSet , OCaml's toplevel displays the module's signature. Since it contains a large number of functions, the output copied here is shortened for brevity [...] e elements instead of to_list , which is a new function in OCaml 5.1, or upgrade OCaml by running opam update , then opam upgrade ocaml . Check your curr

    Data Structures