The Objective Caml system release 3.06 - The Caml language - Inria

46
# let l = new intlist [1; 2; 3];;
val l : ’_a intlist =
# l#fold (fun x y -> x+y) 0;;
- : int = 6
# l;;
- : int intlist =
# l#fold (fun s x -> s ^ string_of_int x ^ " ") "";;
This expression has type int but is here used with type string
Our iterator works, as shows its first use for summation. However, since objects themselves are not
polymorphic (only their constructors are), using the fold method fixes its type for this individual
object. Our next attempt to use it as a string iterator fails.
The problem here is that quantification was wrongly located: this is not the class we want to
be polymorphic, but the fold method. This can be achieved by giving an explicitly polymorphic
type in the method definition.
# class intlist (l : int list) =
# object
# method empty = (l = [])
# method fold : ’a. (’a -> int -> ’a) -> ’a -> ’a =
# fun f accu -> List.fold_left f accu l
# end;;
class intlist :
int list ->
object method empty : bool method fold : (’a -> int -> ’a) -> ’a -> ’a end
# let l = new intlist [1; 2; 3];;
val l : intlist =
# l#fold (fun x y -> x+y) 0;;
- : int = 6
# l#fold (fun s x -> s ^ string_of_int x ^ " ") "";;
- : string = "1 2 3 "
As you can see in the class type shown by the compiler, while polymorphic method types must be
fully explicit in class definitions (appearing immediately after the method name), they can be left
implicit in class descriptions.
However, the type can be completely omitted in the class definition if it is already known,
through inheritance or type constraints on self. Here is an example of method overriding.
# class intlist_rev l =
# object
# inherit intlist l
# method fold f accu = List.fold_left f accu (List.rev l)
# end;;
The following idiom separates description and definition.