153 lines
3.1 KiB
Markdown
153 lines
3.1 KiB
Markdown
CAML is a categorical abstract machine language. It is strongly typed. It was created by INRIA in 1984.
|
|
|
|
## 1.1. General idea
|
|
It's a simple language to write.
|
|
```Ocaml
|
|
# 1+2 ;;
|
|
```
|
|
|
|
- **#** is the prompt (we don't have to write it)
|
|
- **1 + 2** is the program
|
|
- **;;** is the end of the line
|
|
|
|
```Ocaml
|
|
_: int=3 *That a Caml answer to the previus program*
|
|
```
|
|
|
|
```Ocaml
|
|
# 1+2.2;; *That an error*
|
|
|
|
# 1. +. 2.2;; *This is good*
|
|
```
|
|
## 1.2. CAML interaction
|
|
```Ocaml
|
|
# 1;; *He can be a simple expression*
|
|
_: int=1
|
|
|
|
# "Hello World";; *He can be a string*
|
|
_:string = "Hello World"
|
|
```
|
|
|
|
The general form is :
|
|
```Ocaml
|
|
# expr ;;
|
|
_: type of the evaluation = result of the evaluation
|
|
```
|
|
|
|
## 1.3. Definitions
|
|
### Global definitions
|
|
```Ocaml
|
|
# let x=1+2;;
|
|
val x:int = 3 *our current env is x -> 3*
|
|
|
|
# let y=x/2;;
|
|
val y:int = 1 *our current env is x -> 3 ; y -> 1*
|
|
|
|
# let x = 2
|
|
_:bool = false
|
|
|
|
# x;;
|
|
_: int = 2
|
|
|
|
# let name = expr;;
|
|
val name: type of evaluation
|
|
```
|
|
### Local definitions
|
|
```Ocaml
|
|
# let r = 1. in let pi = 3.14 in 2*pi*r;;
|
|
_ : float = 6.28
|
|
|
|
# let x = 10 in y = 2*x in x+y;;
|
|
_ : float = 30
|
|
|
|
# x;;
|
|
_ : int =2 *see global definition section*
|
|
|
|
# pi;;
|
|
error: unbound value pi
|
|
```
|
|
|
|
when there is the keyword ``len``and ``in`` that create a local definition. A local definition is something that only exist in our expression and then it disappear. You can define a local definition into a variable : `` let x = let r = 1. in let pi = 3.14 in 2*pi*r;;`` (for example)
|
|
|
|
### Multiple definitions
|
|
```Ocaml
|
|
# let r = 1. and pi : 3.14 in 2 *. pi *. r;; *local version*
|
|
_ : float = 6.28
|
|
|
|
# let x = 1.2 and y = "Hello";;
|
|
val x: float = 1.2 *our current env is x -> 3 ; y -> 1 ; x -> 1.2 *
|
|
val y: string = "Hello" *our current env is x -> 3 ; y -> 1 ; x -> 1.2 ; y -> "Hello"*
|
|
|
|
# let x = 2 and y = x + 1 in y + 2;;
|
|
Error *because x is 1.2 in our current evaluation*
|
|
```
|
|
> ⚠️ We have only one `let` and one `in` for the multiple definitions methods
|
|
|
|
## 1.4 Basic types
|
|
- Integer: ``int``
|
|
- Compatible operator : + ; - ; * ; / ; mod
|
|
- Same operator priority than in mathematics
|
|
```Ocaml
|
|
# 2+3*2;;
|
|
_: int = 8
|
|
|
|
# (2+3)*3;;
|
|
_: int = 10
|
|
|
|
# max_int 1 073 741 823
|
|
_: int = 2^30-1
|
|
|
|
# max_int -1 073 741 824
|
|
_: int = -2^30
|
|
```
|
|
- Float: ``float``
|
|
- Compatible operator : -. ; +. ; * . ; /.
|
|
- Booleans: ``bool``
|
|
- Can be ``true``or ``false``
|
|
```Ocaml
|
|
# let x = 2 and y = 1 in x/y > 1;;
|
|
_: bool = true
|
|
|
|
# let x = 2 and y = 0 in x/y > 1;;
|
|
Exception: Division by zero
|
|
|
|
# let x = 2 and y = 0 in y<>0 && x/y> 1;;
|
|
_: bool = false
|
|
```
|
|
|
|
|
|
- Char: `char`
|
|
- 8 bits -> extended ASCII table
|
|
```Ocaml
|
|
# 'a'= 'A';;
|
|
_: bool = false
|
|
|
|
# 'a'
|
|
- : char = 'a'
|
|
```
|
|
|
|
- String: `string`
|
|
```Ocaml
|
|
# "ab" < "abc" ;;
|
|
_: bool = true *because O chars -> 2^24 - 6 chars*
|
|
|
|
# "Hello" ^" World"
|
|
_: string = "Hello World"
|
|
|
|
# "abc".[1]
|
|
_: char = "b"
|
|
```
|
|
⚠️ Les minuscules passent avant les majuscules
|
|
|
|
### Comparaison
|
|
|
|
|Mathematics|$=$|$\not=$|$<$|$>$|$\eqslantgtr$|$\eqslantless$|
|
|
|:----:|:----:|:----:|:----:|:----:|:----:|
|
|
|CAML|`=`|`<>`|`<`|`>`|`<=`|`>=`|
|
|
|
|
|CAML|Maths|English|
|
|
|:-----|:-----|:-----|
|
|
|not|$\neg$|negation|
|
|
|&&|$\land$|and|
|
|
|// (barre oblique)|$\lor$|or (inclusive)|
|