Learning About Names and Functions in OCaml

In chapter 2 of OCaml from the very beginning, I learned the following:

Naming an expression

• Use the following constructs to define our own name (e.g., x) to stand for the result of evaluating an expression:
  • let x = (expression) ;;
  • let x = (expression) in (another expression) ;;
• OCaml replies to confirm that an expression x is named, and confirm its type and value.  E.g., let x = 200 ;; :

        val x : int = 200

Naming a function

• Use the following construct to define a function (e.g. cube) that takes an argument (e.g. x), and applies it to the function as defined:
  • let cube x = x * x * x ;;
• OCaml replies to confirm that a function cube is named, and confirm the type of the argument(s) it takes, and the type of the value the function evaluates to:

        val cube : int -> int : <fun>

Naming a recursive function

• A recursive function is a function which uses itself.  That is, when we define such a function, its own function name has to be in the function definition.
• Use the following construct to define a recursive function (e.g. factorial) that takes an argument, and applies it to the function as defined:
  • let rec factorial x =
    if x = 1 then 1 else factorial (x – 1) * x ;;
• OCaml replies similarly to when a function is defined, telling us the types of the argument(s) and the value the function evaluates to:    

        val factorial : int -> int = <fun>

• Make sure that any recursive function you define terminates.  Check that you have given the recursive function a way to terminate in all cases of the appropriate type of the argument(s).
• OCaml has a built-in function named not.  not takes an argument of type bool and returns a value of type bool.  That is, when you type ‘not’ in OCaml, it replies with:

        – : bool -> bool = <fun>