- 101 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about 'Introduction to Objective Caml' - kadeem

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

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

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 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)

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 =

# add (3, 5);;

- : int = 8

- Notice the type of add: int * int -> int =
- The -> indicates that this is a function
- The value (function body) is abbreviated to

Download Presentation

Connecting to Server..