1 MP -- Basic OCaml
CS 440 -- Fall 2007
Revision 1.0 Assigned September 14, 2007 Due September 24, 2007
1
Objectives
This MP is designed to give you experience with basic OCaml syntax. We assume that you have not seen OCaml before, and have not used a functional programming language before, and so this functions as a tutorial. Objectives: Know how to manipulate the integer, float, string, Boolean, and tuple types. Know how to write functions of single and multiple variables. Know how to write simple recursive functions over integers.
2
2.1
Background
Interactive Compiler
OCaml has two modes that we will use. The first is as an interactive compiler, the second is as a standalone compiler. The interactive compiler is started simply by typing ocaml at the command prompt. You will get a screen that looks like this: Objective Caml version 3.09.2 # The version number may change a bit, don't worry about that. The # character is the prompt in OCaml. You will type in an expression or a command for the compiler. When you are done, OCaml will compile the expression and evaluate it, and then display the result. For example, to evaluate "3 + 5", your session would look like this: Objective Caml version 3.09.2 # 3 + 5 ;; - : int = 8 # The two semicolons at the end are used in the interactive compiler to signal that you are finished entering an expression. They are not needed for a standalone program, and should not be entered.
2.2
Variables
Global Variables To declare a global variable, use the let keyword: # let x = 3 + 5;; val x : int = 8 You will not have need to declare these often in real programs, but they can be useful for development purposes. 1
Local Variables A local let expression has the form let x = e1 in e2 This whole expression has two subexpressions. The subexpression e1 will be evaluated first and its value assigned to x. This variable is available to the subexpression e2 , which is evaluated next. The value of e2 will be considered the value of the entire let expression, and once it is finished the variable x goes out of scope and is destroyed. # let y = 3 in y + 5;; - : int = 8 Since a local let is an expression, it can be nested inside of another local let. # let y = 3 in let z = 5 in y + z;; - : int = 8 If there are multiple variables defined with the same name, the compiler will take the variable from the innermost scope first. The next example shows a global x and a local x which is used and then goes out of scope. # let x = 10;; val x : int = 10 # x + 5;; - : int = 15 # let x = 20 in x + 5;; - : int = 25 # x + 5;; - : int = 15 You should try different combinations of these to gain an intuition for how these work.
2.3
Writing Functions
A function declaration looks like a global let. let f x y = e The above shows a function named f with two parameters x and y. The body of the function is the expression e. There is no limit to the number of parameters, as long as there is at least one. (A function with no parameters is simply a variable.) # let inc x = x + 1;; val inc : int -> int = <fun> # inc 20;; - : int = 21 # let plus a b = a + b;; val plus : int -> int -> int = <fun> # plus 10 5;; - : int = 15 # let x = 3 in plus x 5;; - : int = 8
2
2.4
Recursive Functions
By adding the rec keyword, a function is made recursive. # let rec countdown n = if n < 1 then 0 else n + (countdown (n-1));; val countdown : int -> int = <fun> # countdown 5;; - : int = 15
2.5
Local Functions
Many functions need helper functions, but usually there's no reason to have the helper function be visible to the outside world. In such a case, it is best to declare it as a local function by combining the syntax for functions and local variables. This is a common technique. # let rms a b = let sqr x = x *. x in sqrt (sqr a +. sqr b);; val rms : float -> float -> float = <fun> # rms 3.0 4.0;; - : float = 5.
2.6
Type Conversion
OCaml is a strictly typed language. If a value of one type needs to be in a context expecting a different type, the value must first be converted. There are a number of built-in functions to accomplish this. string of int : int -> string float -> string
string of float : int of float : float of int :
float -> int int -> float
Tuples Comma-separated values placed in parenthesis are called tuples. Usually the word tuple denotes two elements, and we can use the word pair to describe it, but any number is possible. A tuple with, for example, six elements will be called a 6-tuple. A tuple is considered a single parameter. Properly speaking, it is a (reference to a) data-structure which has references to its contents. In order for a tuple to be useful, there needs to be a way of accessing the contents. Here are three ways. The first way is to place the tuple in the function declaration itself. # let plust (a,b) = a + b;; val plust : int * int -> int = <fun> Note the type of the function: the asterisk should remind you of Cartesian products. The second way is to declare a tuple of variables with a local let. The following code takes a tuple and x deconstructs it into its component parts. # let plust x = let (a,b) = x in a + b;; val plust : int * int -> int = <fun> 3
The third way is to use built-in functions fst and snd. They can only be used for pairs, however. # let plust x = (fst x) + (snd x);; val plust : int * int -> int = <fun> All three of the above functions produce identical results. There is a fourth way, using the match keyword, but that will be introduced in a future MP.
3
Sectioning
Notice the type of the following function: # let plus a b = a + b;; val plus : int -> int -> int = <fun> What does the type mean? The -> indicates a function. There are two ways to interpret this. The first interpretation is that plus is a function that takes two integers and returns an integer result. An equally valid interpretation is that plus takes an integer and returns a function, which itself takes an integer and returns an integer result. Whenever a function is given a proper subset of its arguments, the result is another function. This is called sectioning. Here is an example using plus. # let inc = plus 1;; val inc : int -> int = <fun> # inc 34;; - : int = 35 One useful shortcut in OCaml is that the built-in infix operators can be made into prefix operators by surrounding them with parentheses. These functions can then be sectioned. # let inc = (+) 1;; val inc : int -> int = <fun> Be careful if you want to section the multiplication operator. It is necessary to add a space before the first parenthesis and the asterisk, because (* is the begin comment delimiter. Use ( * ) to make multiplication into a prefix function.
4
Problems
1. Write a function timesi : 2. Write a function timesf : 3. Write a function timesti : int -> int -> int which multiplies two integers. float -> float -> float which multiplies two floats. int * int -> int which multiplies two integers in a tuple.
The following problems will help you practice the above concepts.
4. Write a function timess : string -> string -> string which takes the string representations of two integers and returns a string representation of their product. 5. Write a function double : 6. Write a function fact : int -> int, using the sectioning technique and the timesi function.
int -> int which returns the factorial of its argument.
4
7. Write a function pow : int -> int -> int which returns xn when given n and x in that order. (The operator ** will perform floating point exponentiation, but for this problem you must use recursion.) 8. Write a function foo : int -> int which takes an argument x and returns a2 + 3 a3 + 4 a7 , where a = x!. You should call the factorial function precisely one time for this function; the purpose of having you write it is to give you practice with local let expressions. 9. Write a function calc : int -> int which runs the "calculator game". The calculator game is this: start with a number x. If x is even, divide by two and play again. If x is odd, multiply by three and add ...