introduction to objective caml
Download
Skip this Video
Download Presentation
Introduction to Objective Caml

Loading in 2 Seconds...

play fullscreen
1 / 24

Introduction to Objective Caml - PowerPoint PPT Presentation


  • 101 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
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
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
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
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
  • 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
  • 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
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
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 bool s
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
  • 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
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
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
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
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
  • 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
  • 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
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
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
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
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 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
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
ad