Introduction to Objective Caml

1. Introduction to Objective Caml

2. General comments • ML is a purely functional language--there are (almost) no side effects • There are two basic dialects of ML • Standard ML • Caml (including Objective Caml, or OCaml) • ML is interactive • ML is case-sensitive • ML is strongly typed

3. Using Objective Caml

4. Programs on files • Save your program file with a .ml extension • As always, use a decent text editor • To load a program: • Choose File -> Open... • Click OK (to clear the input pane) • Navigate to your file and open it • Hit the Return key in the terminal input window

5. Two kinds of Enter! • The Enter key on the main keyboard sends your expression to Ocaml to be executed • The Enter key on the numeric keypad just gives you a new line in the input pane • If you copy and paste code from another source, you may get mysterious errors • Replace each newline with the keypad kind!

6. Comments • Comments are enclosed in (* and *) • Comments can be nested • Nested comments are useful for commenting out a block of code that may itself contain comments

7. Identifiers • Identifiers are composed of letters, digits, underscores ( _ ), and primes ( ' ) • Normal variables must start with a lowercase letter • "prime" = "apostrophe" = "single quote" = "tick" • Only "type variables" can start with a prime • An underscore all by itself, _, is a wildcard

8. Primitive types • int 0, 5, 42, -17, 0x00FF • Negative ints often need to be parenthized: (-1) • float 0.0, -5.3, 1.7e14, 1e-10 • Cannot start with a decimal point • bool true, false • string "", "One\nTwo\nThree" • char 'a', '\n'

9. Trying things at the prompt • End expressions with a double semicolon, ;; # 2 + 2;; - : int = 4 # let five = 5;; val five : int = 5 # 2 + five;; - : int = 7 • Caml shows you the type because it's important

10. Operations on bools • Comparisons give a bool result < <= = <> >= > • Standard operators are not, &&, || • # (1 < 3) && (3 <= 5);; - : bool = true • && and || are short-circuit operators • There is an and, but it's something else entirely

11. Arithmetic • Arithmetic on integers: + - * / 2 + 2;; # - : int = 4 • Arithmetic on floats: +. -. *. /. # 2.0 +. 2.0;; - : float = 4.000000 # 2.0 + 2.0;; # Characters 6-9:This expression has type float but is here used with type int

12. No mixed-mode arithmetic # 5 + 3.0;; # Characters 4-7:This expression has type float but is here used with type int # 5 +. 3.0;; # Characters 0-1:This expression has type int but is here used with type float

13. Numeric coercions #float 5;; - : float = 5.000000 # truncate 3.8;; - : int = 3 # floor 3.8;; - : float = 3.000000 # ceil 3.8;; - : float = 4.000000

14. Comparisons • Comparisions < <= = <> >= > can be applied to any type • Comparisons have their usual meanings for primitive types (int, float, bool, string, char) • Their meaning is undefined for more complex types • The comparisons == and != test whether two things occupy the same storage locations

15. Operations on strings and chars • ^ is string concatenation • String.length s returns the size of string s • String.index s c finds character c in string s • String.sub s p n returns a substring of s of length n starting from p • String.uppercase s uppercases all letters in s • String.capitalize s uppercases the first character in s

16. Lists • Lists are semicolon-separated and enclosed in brackets • # [3; 5; 7];; - : int list = [3; 5; 7] • All elements of a list must be the same type • Note that the type above is given as int list

17. The empty list • The empty list is represented by [ ] • The empty list has a type • When Caml doesn't know the type, it represents it with a type variable'a, 'b, 'c, ... • # [ ];; - : 'a list = [] • Sometimes Caml does know the type of [ ] !

18. Operations on lists • hd returns the head (CAR) of a list • tl returns the tail (CDR) of a list • :: adds an element to a list (CONS) • Example: 1 :: [3; 5; 7] gives [1; 3; 5; 7] • @ appends two lists (APPEND) • List.length l returns the length of l • List.nth l n returns the nth element of l

19. Tuples • Elements of a tuple are separated by commas • Tuples are usually enclosed in parentheses • # ("pi", 3.1416, [1;2;3]);; - : string * float * int list = "pi", 3.141600, [1; 2; 3] • Notice the type: (string * float * int list) • [(3, 5.0); (3.0, 5)] isn't legal--why not?

20. Tuples of different sizes • Notice the types in the following: • # (1, 2, 3);; - : int * int * int = 1, 2, 3 # (1, 2);; - : int * int = 1, 2 # (1);; - : int = 1 (* Why is this an int? *) • For x of any type, (x) is the same as x

21. Operations on tuples • A pair is a tuple of two elements • fst t is the first element of a pair tsnd t is the second element of a pair t • That's all! • You can define additional operations on tuples by using pattern matching (more about that later)

22. The unit • The empty tuple is represented as ( ) • The empty tuple is called the "unit" • There is (obviously) only one value of this type, but it is a value • There are a (very) few places where we use the unit because we need to provide a value but don't care what it is.

23. Defining a simple function • # let add (x, y) = x + y;; val add : int * int -> int = <fun> # add (3, 5);; - : int = 8 • Notice the type of add: int * int -> int = <fun> • The -> indicates that this is a function • The value (function body) is abbreviated to <fun>

24. The End