File created 2 February 2001.
Simple and basic programs
How to compile the programs
Calling the Caml compiler:
- to compile the file
hello.ml
to executable
program a.out
, simply type
ocamlc hello.ml
- to compile the file
hello.ml
to executable
program hello
type
ocamlc -o hello hello.ml
How to run the programs
To run the compiled programs, use them as ordinary commands.
For instance, to try the Caml programs fib
, wc
,
or sieve
, type in:
fib 10 # or some other number
wc fib.ml # or some other files
sieve 1000 # or some other number
How to try and test the programs with the interactive system
To try the programs interactively: call the Caml interactive system and load
the programs using the #load
directive.
ocaml # or better, ledit ocaml, if ledit is installed.
Then type in (don't forget to type the initial #
sign, that
indicates a directive)
#use "fib.ml";;
In sub directories that contain complex examples, a Caml source file
named loadall.ml
is provided. In this case just type:
#use "loadall.ml";;
Automatic recompilation
In sub directories that contain complex examples, a Makefile
is
provided to automatically compile the set of Caml source files needed to
compile and link the program.
To compile and link the program: either type "make", or, type manually the
output of the make command:
ocamlc -o fib fib.ml
ocamlc -o wc wc.ml
ocamlc -o sieve sieve.ml
As mentioned above, you can also try the programs interactively:
ocaml # or ledit ocaml if ledit is installed.
#use "loadall.ml";;
Native code compilation
To compile the programs to native code: either type "make opt" is
a Makefile
is provided, or, type manually the suitable commmands:
ocamlopt -o fib fib.ml
ocamlopt -o wc wc.ml
ocamlopt -o sieve sieve.ml
Basic programs
This directory contains the following basic programs:
- Hello: the source program is in file
hello.ml
.
- It just prints "Hello world!" followed by a newline.
- Try
hello
- Greeting: the source program is in file
greeting.ml
.
- It asks the name of the user, reads the input from the keyboard,
greets the user and dies.
- Try
greeting
- Argcargv: the source program is in file
argcargv.ml
.
- It prints the number of arguments passed to the program on the
command line, then prints them all.
- Try
argcargv 1 Camel
- Square: the source program is in file
square.ml
.
- It reads an integer passed as argument to the program, then computes
and prints the square of the integer.
- Try
square 16
- Fib: the source program is in file
fib.ml
.
- It defines the Fibonacci function as a simple recursive
Caml function.
- Try
fib 10
- Wc: the source program is in file
wc.ml
.
- A program that mimicks the Unix "wc" utility: it counts the number of
characters, words, and lines of a given file.
- Try
./wc wc.ml
- Wc_unix: the source program is in file
wc_unix.ml
.
- This is a Caml clone of the Unix "wc" utility.
- Try
./wc_unix *.ml
- Reverse_stdin: the source program is in file
reverse_stdin.ml
.
- It reverses the lines read from stdin.
Vectors and imperative programming with loops.
- Try
reverse_stdin < reverse_stdin.ml
- Reverse_rec: the source program is in file
reverse_rec.ml
.
- Also reverses the lines read from stdin.
Elegant recursive imperative programming.
- Try
reverse_rec < reverse_stdin.ml
- Sieve: the source program is in file
sieve.ml
.
- The Eratosthene's sieve: the program computes the set of prime
numbers lesser than a given integer argument.
Uses lists.
- Try
sieve 1000
- Sieve_vect: the source program is in file
sieve_vect.ml
.
- The Eratosthene's sieve in an imperative way, using a vector:
the program computes the number of prime numbers lesser than a given
integer argument.
Uses and manipulates vectors.
- Try
sieve_vect 1000
- Note: the C correspondant of
sieve_vect.ml
is in file
sieve_vect.c
.
The Caml correspondant with maximum speed is in
sieve_vect_unsafe.ml
(no array bound checks).
- Qeens: the source program is in file
queens.ml
.
- Lists manipulation: prints the solution to the 8 queens problem.
- How to set n queens on a chessboard of size n such that none
can catch one each other.
Higher-order list manipulation.
- Try
queens 8
- Soli: the source program is in file
soli.ml
.
- It prints a solution to the famous ``solitaire'' game.
Vectors and data types definitions and manipulation.
- Try
soli
Simple library modules
This directory contains two simple library module examples:
- Realloc: module Realloc, the source
implementation of the module is in file
realloc.ml
, the source
interface of the module is in file
realloc.mli
.
- Defines a simple module to realloc (enlarge) arrays.
The module defines and exports a single realloc function.
Try to define and compile a program that uses realloc (for instance
to define dynamically extendable storage areas).
- Explode: module Explode, the source
implementation is in file
explode.ml
,
the interface is in file
explode.mli
.
- Defines explode and implode, two simple functions that convert a
string into a list of chars (explode) and converse (implode).
Those functons are linear and tail recursive.
Advanced programs
This directory contains the following less simple programs:
- Strpos: the source program is in file
strpos.ml
.
- Tests if its first argument appears as a sub string of its second
argument, and returns the first character index of the first matching
occurrence.
Uses recursive function programming to implement a naive algorithm.
- Try
strpos rs strstr
strpos ra strstr
- Kmp: the source program is in file
kmp.ml
.
- Tests if its first argument appears as a sub string of its second
argument, and returns the first character index of the first matching
occurrence.
Uses imperative programming, while loops and references to
implement the Knuth-Morris-Pratt algorithm.
- Try
kmp rs strstr
kmp ra strstr
- Qeens_tail: the source program is in file
queens_tail.ml
.
- Same as Queens but the program is optimized, being written in a
so called ``tail rec'' style.
Interesting tail recursion exercise.
- Try
queens_tail 8
- Qeens_lazy: the source program is in file
queens_lazy.ml
.
- Same as Queens but the program is written in lazy style.
Lazyness is hand coded, hence extremely explicit.
Defines sum types to implement lazy lists, use mutable fields to
implement call by need.
Strange mixing of side effects and pure functionality.
- Try
queens_lazy 8
Contact the
author Pierre.Weis@inria.fr