Part 3 - Induction and recursionExercisesType-inference by yourselfDocumentation and user's manualTable of contentsOCaml programs

Type-inference by yourself

To check your solution enter an Objective Caml toplevel from a directory containing the files  List_1.cmi  and  List_1.cmo  (in other words: the module  List_1 ) to be extracted from  this archive . Then in this toplevel first evaluate this Caml code:

#load "List_1.cmo" ;;

open List_1 ;;

This loads the module  List_1  then opens it, which allows to use short names instead of long ones in dotted notation (that is, for instance  cons_list  instead of  List_1.cons_list ).

All the following Caml phrases are syntactically correct. They are assumed to be evaluated in order. Consider each of them. Is it a value definition let ... = e or an expression e? Has e a value? If it has a value then which one and of which type? Else why?

let li_1 = cons_list (7, cons_list (3, cons_list (11, empty_list ()))) ;;
cons_list (2, 3) ;;
cons_list (empty_list (), 7) ;;
let li_2 = cons_list (9, li_1)
in li_2 ;;
li_1 ;;
li_2 ;;
empty_list () ;;
empty_list ;;
let li_2 = cons_list (6, cons_list (5, cons_list (9, empty_list ()))) ;;
cons_list (li_2, cons_list (li_1, empty_list ())) ;;
cons_list (6, cons_list (li_1, empty_list ())) ;;
let li_3 = cons_list (6, cons_list (5.3, cons_list (9, empty_list ()))) ;;
let li_4 = cons_list ("bear", cons_list ("cow", cons_list ("fox", empty_list ()))) ;;
let li_5 = cons_list ("honey", cons_list ("grass", cons_list ("hen", empty_list ()))) ;;
cons_list (li_4, li_5) ;;
tail (tail (cons_list ("yes", empty_list ()))) ;;
cons_list ("yes", empty_list ()) ;;
cons_list ((2, 3.5), cons_list ((0, 4.), empty_list ())) ;;
head (tail (cons_list ((if 4 > 2 then 3 < 5
                                 else 3 > 5),
         l             empty_list ()))) ;;
cons_list ((if 4 > 2 then 3 < 5
                     else 3 > 5),
           empty_list ()) ;;
cons_list (li_1, (cons_list (empty_list (), cons_list (cons_list (4, li_2), empty_list ())))) ;;
tail (cons_list (5, empty_list ())) ;;
let rec f1 = function li -> if is_empty_list (tail (li)) then head (li)
                                                         else f1 (tail (li)) ;;
let rec f2 = function (li, n) -> if n = 1 then head (li)
                                          else f2 (tail (li), n - 1) ;;
cons_list (empty_list (), empty_list ()) ;;
cons_list (cons_list (empty_list (), empty_list ()), empty_list ()) ;;
cons_list (sqrt, cons_list (log, cons_list (exp, empty_list ()))) ;;
cons_list (empty_list, empty_list ()) ;;
cons_list (empty_list (), empty_list) ;;
cons_list (empty_list, empty_list) ;;
let rec f3 = function (li, li1) ->
  if is_empty_list (li) 
    then li1 
    else if is_empty_list (li1)
           then li
           else if head (li) <= head (li1)
                  then cons_list (head (li), f3 (tail (li), li1))
                  else cons_list (head (li1), f3 (li, tail (li1))) ;;
let rec f4 = function li ->
  if is_empty_list (li)
    then (li, empty_list ()) 
    else if is_empty_list (tail (li))
           then (li, empty_list ())
           else let (h1, h2) = f4 (tail (tail (li)))
                in (cons_list (head (li), h1), cons_list (head (tail (li)), h2)) ;;
let rec f5 = function li ->
  if is_empty_list (li) then li
                        else if is_empty_list (tail (li))
                                then li
                                else let (h1, h2) = f4 (li) 
                                     in f3 (f5 (h1), f5 (h2)) ;;
let rec f6 = function (li, li1 ) ->
  if is_empty_list (li) & is_empty_list (li1) 
    then empty_list ()
    else cons_list ((head (li), head (li1)),
                f6 (tail (li), tail (li1))) ;;
let rec f7 = function li -> if is_empty_list (li) then f7 (cons_list (0, li))
                                                  else f7 (li) ;;
f7 (cons_list (2, empty_list ())) ;;
let rec f8 = function li -> if is_empty_list (li) then tail (li)
                                                  else f8 (tail (li)) ;;
f8 (cons_list (2, empty_list ())) ;;
let rec f9 = function
  li -> if is_empty_list (li)
          then empty_list ()
          else if is_empty_list (tail (li)) then head (li) else tail (li) ;;
f9 (cons_list (2, empty_list ())) ;;
let rec f10 = function li ->
  if is_empty_list (li) then li
                        else cons_list (head (li), f10 (tail (li))) ;;
f10 (cons_list (3, cons_list (2, empty_list ()))) ;; 
head (tail (tail (li_1))) ;;
is_empty_list (cons_list (3.5, empty_list ())) ;;
is_empty_list (tail (tail (tail (li_4)))) ;;
is_empty_list (empty_list ()) ;;
(f1 (li_1), f1 (li_4)) ;;
let li = f5 (f3 (li_1, li_2)) 
in (f2 (li, 1), f2 (li, 2), f2 (li, 3), f2 (li, 4), f2 (li, 5), f2 (li, 6)) ;;
li ;;
let li = f5 (f3 (li_4, li_5)) 
in (f2 (li, 1), f2 (li, 2), f2 (li, 3), f2 (li, 4), f2 (li, 5), f2 (li, 6)) ;;
let li = f6 (li_4, li_5) 
in (f2 (li, 1), f2 (li, 2), f2 (li, 3)) ;;


Latest update : October 5, 2006
This document was translated from LaTeX by Hyperlatex 2.5, which is not the latest version of Hyperlatex.

Part 3 - Induction and recursionExercisesType-inference by yourselfDocumentation and user's manualTable of contentsOCaml programs