Introduction to objective caml
This presentation is the property of its rightful owner.
Sponsored Links
1 / 24

Introduction to Objective Caml PowerPoint PPT Presentation


  • 69 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

Introduction to Objective Caml

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


Introduction to objective caml

Introduction to Objective Caml


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


Using objective caml

Using Objective Caml


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

The End


  • Login