utop[1]> make_disk0 40.;;
- : mycomplex -> bool = <fun>
utop[2]> point_in_zone_p;;
- : mycomplex -> zone -> bool = <fun>
utop[3]> point_in_zone_p (make_complex 10. 10.0) (make_disk0 40.);;
- : bool = true
utop[4]> point_in_zone_p (make_complex 40. 40.0) (make_disk0 40.);;
- : bool = false
utop[5]> let d0 = make_disk0 40.;;
val d0 : mycomplex -> bool = <fun>
utop[6]> d0;;
- : mycomplex -> bool = <fun>
utop[7]> view_zone d0;;
- : Unix.process_status = Unix.WEXITED 0
utop[8]> view_zone (make_disk 30. (make_complex 20. 20.));;
- : Unix.process_status = Unix.WEXITED 0
utop[9]> view_zone (move_zone d0 (make_complex 50. 20.));;
- : Unix.process_status = Unix.WEXITED 0
utop[10]> make_rectangle;;
- : float -> float -> mycomplex -> bool = <fun>
utop[11]> make_rectangle 20. 30.;;
- : mycomplex -> bool = <fun>
utop[12]> view_zone (make_rectangle 20. 30.);;
- : Unix.process_status = Unix.WEXITED 0
utop[13]> view_zone (move_zone (make_rectangle 20. 30.) (make_complex 30. 50.));;
- : Unix.process_status = Unix.WEXITED 0
utop[14]> rotate_zone0;;
- : zone -> float -> mycomplex -> bool = <fun>
utop[15]> (rotate_zone0 (make_rectangle 20. 30.) 1.5);;
- : mycomplex -> bool = <fun>
utop[16]> view_zone (rotate_zone0 (make_rectangle 20. 30.) 1.5);;
- : Unix.process_status = Unix.WEXITED 0
utop[18]> view_zone (move_zone (rotate_zone0 (make_rectangle 20. 30.) 1.5) (make_complex 20. 20.));;
- : Unix.process_status = Unix.WEXITED 0
utop[19]> view_zone everywhere;;
- : Unix.process_status = Unix.WEXITED 0
utop[20]> view_zone (zone_difference everywhere (make_disk0 40.));;
- : Unix.process_status = Unix.WEXITED 0
utop[21]> let maison =
  let r = make_rectangle 21. 21. 
  and porte = move_zone (make_rectangle 7. 10.) (C(7., 0.))
  and toit = rotate_zone (move_zone (make_rectangle 16. 16.) (C(10.5, 10.5)))
		       (3.14116 /. 4.) (C(10.5, 10.5)) in
  let corps = zone_difference (zone_union toit r) porte
  and fenetre = make_disk0 2. in
  let maison = zone_difference
    (zone_difference corps
		     (move_zone fenetre (C(6., 15.))))
    (move_zone fenetre (C(15., 15.))) in
  move_zone maison (C(27., 3.))
  (*  rotate_zone (move_zone maison (C(27., 3.))) (3.1416 /. 2.) (C(27., 3.)) *)

;;
val maison : mycomplex -> bool = <fun>
utop[22]> view_zone maison;;
- : Unix.process_status = Unix.WEXITED 0
utop[23]> view_zone (zone_union maison (make_disk 10. (make_complex 80. 80.)));;
- : Unix.process_status = Unix.WEXITED 0
utop[24]> type mycomplex = C of float * float;;
type mycomplex = C of float * float
utop[25]> let realpart z = let C(x, _) = z in x;;
val realpart : mycomplex -> float = <fun>
utop[26]> let imagpart z = let C(_, y) = z in y;;
val imagpart : mycomplex -> float = <fun>
utop[27]> let make_complex x y = C(x, y);;
val make_complex : float -> float -> mycomplex = <fun>
utop[28]> let c_scal lambda z =
  make_complex
    (lambda * realpart z)
    (lambda * imagpart z)

    ;;
Line 3, characters 14-24:
Error: This expression has type float but an expression was expected of type
         int
utop[29]> let c_scal lambda z =
  make_complex
    (lambda *. realpart z)
    (lambda *. imagpart z)

    ;;
val c_scal : float -> mycomplex -> mycomplex = <fun>
utop[30]> type complex = { real: float; imag: float};;
type complex = { real : float; imag : float; }
utop[31]> let make_complex x y = { real = 1.0 ; imag = 0.};;
val make_complex : 'a -> 'b -> complex = <fun>
utop[32]> { imag=2. ; real=0.};;
- : complex = {real = 0.; imag = 2.}
utop[33]> let z= { imag=2. ; real=0.};;
val z : complex = {real = 0.; imag = 2.}
utop[34]> z;;
- : complex = {real = 0.; imag = 2.}
utop[35]> z.real;;
- : float = 0.
utop[36]> z.imag;;
- : float = 2.
utop[37]> let realpart z = z.real;;
val realpart : complex -> float = <fun>
utop[38]> let imagpart z = z.imag;;
val imagpart : complex -> float = <fun>
utop[39]> let c_scal lambda z =
  make_complex
    (lambda *. realpart z)
    (lambda *. imagpart z)

    
;;
val c_scal : float -> complex -> complex = <fun>
utop[40]> let z = make_complex 10. 20.;;
val z : complex = {real = 1.; imag = 0.}
utop[41]> c_scal 3. z;;
- : complex = {real = 1.; imag = 0.}
utop[42]> type intlist = NI | CI of int * intlist;;
type intlist = NI | CI of int * intlist
utop[43]> NI;;
- : intlist = NI
utop[44]> CI(1,NI);;
- : intlist = CI (1, NI)
utop[46]> CI(1,CI(2,NI));;
- : intlist = CI (1, CI (2, NI))
utop[49]> CI(1,CI(2,(CI(3,NI))));;
- : intlist = CI (1, CI (2, CI (3, NI)))
utop[50]>