introduction to objective caml. general comments ml is a purely functional language--there are...
DESCRIPTION
Using Objective CamlTRANSCRIPT
Introduction to Objective Caml
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
Using Objective Caml
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
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!
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
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
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'
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
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
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
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
Numeric coercions
#float 5;;- : float = 5.000000
# truncate 3.8;;- : int = 3
# floor 3.8;;- : float = 3.000000
# ceil 3.8;;- : float = 4.000000
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
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
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
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 [ ] !
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
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?
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
Operations on tuples
• A pair is a tuple of two elements• fst t is the first element of a pair t
snd 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)
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.
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>
The End