Author: Christian.Queinnec@lip6.fr

## Presenting part I

The first part of this book is a complete introduction to the core of the Objective CAML language, in particular the expression evaluation mechanism, static typing and the data memory model.
An expression is the description of a computation. Evaluation of an expression returns a value at the end of the computation. The execution of an Objective CAML program corresponds to the computation of an expression. Functions, program execution control structures, even conditions or loops, are themselves also expressions.
Static typing guarantees that the computation of an expression cannot cause a run-time type error. In fact, application of a function to some arguments (or actual parameters) isn't accepted unless they all have types compatible with the formal parameters indicated in the definition of the function. Furthermore, the Objective CAML language has type infererence: the compiler automatically determines the most general type of an expression.
Finally a minimal knowledge of the representation of data is indispensable to the programmer in order to master the effects of physical modifications to the data.

#### Outline

Chapter 2 contains a complete presentation of the purely functional part of the language and the constraints due to static typing. The notion of expression evaluation is illustrated there at length. The following control structures are detailed: conditional, function application and pattern matching. The differences between the type and the domain of a function are discussed in order to introduce the exception mechanism. This feature of the language goes beyond the functional context and allows management of computational breakdowns.
Chapter 3 exhibits the imperative style. The constructions there are closer to classic languages. Associative control structures such as sequence and iteration are presented there, as well as mutable data structures. The interaction between physical modifications and sharing of data is then detailed. Type inference is described there in the context of these new constructions.
Chapter 4 compares the two preceding styles and especially presents different mixed styles. This mixture supports in particular the construction of lazy data structures, including mutable ones.
Chapter 5 demonstrates the use of the `Graphics` library included in the language distribution. The basic notions of graphics programming are exhibited there and immediately put into practice. There's even something about GUI construction thanks to the minimal event control provided by this library.
These first four chapters are illustrated by a complete example, the implementation
of a calculator, which evolves from chapter to chapter.
Chapter 6 presents three complete applications: a little database, a mini-BASIC interpreter and the game Minesweeper. The first two examples are constructed mainly in a functional style, while the third is done in an imperative style.

#### The rudiments of syntax

Before beginning we indicate the first elements of the syntax of the language. A program is a sequence of phrases in the language. A phrase is a complete, directly executable syntactic element (an expression, a declaration). A phrase is terminated with a double semi-colon (;;). There are three different types of declarations which are each marked with a different keyword:

value declaration | : | let
exception declaration | : | exception
type declaration | : | type

All the examples given in this part are to be input into the interactive toplevel of the language.
Here's a first (little) Objective CAML program, to be entered into the toplevel, whose prompt is the pound character (`#`), in which a function fact computing the factorial of a natural number, and its application to a natural number `8`, are defined.

    # let rec fact n = if n < 2 then 1 else n * fact(n-1) ;;
    val fact : int -> int = <fun>
    # fact 8 ;;
    - : int = 40320

This program consists of two phrases. The first is the declaration of a function value and the second is an expression. One sees that the toplevel prints out three pieces of information which are: the name being declared, or a dash (`-`) in the case of an expression; the inferred type; and the return value. In the case of a function value, the system prints `<fun>`.
The following example demonstrates the manipulation of functions as values in the language. There we first of all define the function succ which calculates the successor of an integer, then the function compose which composes two functions. The latter will be applied to fact and succ.

    # let succ x = x+1 ;;
    val succ : int -> int = <fun>
    # let compose f g x = f(g x)  ;;
    val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun>
    # compose fact succ 8 ;;
    - : int = 362880

This last call carries out the computation fact`(`succ`` `8``)` and returns the expected result. Let us note that the functions fact and succ are passed as parameters to compose in the same way as the natural number `8`.