The following type
    compare_things : thing -> thing -> ('a -> 'a -> bool) -> bool
doesn't mean that comparison_fun has to be polymorphic, but it means
that any function with type ('a -> 'a -> bool), where 'a is any type, is
acceptable. For instance, the type checker would accept a function of
the type (char -> char -> bool).

If you force the type checker to accept your function, for instance this
way (warning, awful code !):

let compare_things t1 t2 (comparison_fun: 'a -> 'a -> bool) =
  match (t1, t2) with
      (Int i, _) -> comparison_fun (Obj.magic i) (Obj.magic
(int_of_thing t2))
    | (String s, _) -> comparison_fun (Obj.magic s) (Obj.magic
(string_of_thing t2)) ;;


then you can get a segfault if you don't give a polymorphic function to
compare_things :

let string_rev s =
  let l = String.length s in
  let result = String.create l in
  for i=0 to l-1 do result.[i] <- s.[l-i-1] done;
  result

let my_comparison s s' =
  (string_rev s) > (string_rev s')

let ok = compare_things (Int 0) (String "42") (<)
let segfaults = compare_things (Int 0) (String "42") my_comparison


work around: pass 2 args to compare_things, namely compare_int and
compare_strings.
Jean-Baptiste.




Benjamin Geer wrote:

> Can anyone explain to me why the following doesn't compile:
>
> ----------
>
> type thing = Int of int | String of string ;;
>
> let int_of_thing t =
>   match t with
>       Int i -> i
>     | String s -> int_of_string s ;;
>
> let string_of_thing t =
>   match t with
>       Int i -> string_of_int i
>     | String s -> s ;;
>
> let compare_things t1 t2 comparison_fun =
>   match (t1, t2) with
>       (Int i, _) -> comparison_fun i (int_of_thing t2)
>     | (String s, _) -> comparison_fun s (string_of_thing t2) ;;
>
> let is_less_than t1 t2 =
>   compare_things t1 t2 (<) ;;
>
> let is_greater_than t1 t2 =
>   compare_things t1 t2 (>) ;;
>
> ----------
>
> The compiler says:
>
> File "test.ml", line 16, characters 38-39:
> This expression has type string but is here used with type int
>
> It seems to have decided that in the function compare_things, 
> comparison_fun is int -> int -> 'a because that's how it's used in the 
> first pattern, not realising that I mean to pass a polymorphic 
> function, 'a -> 'a -> bool.
>
> Is there a way to make this work?  (Specifying the type of 
> comparison_fun as 'a -> 'a -> bool makes no difference.)
>
> Ben
>
> -------------------
> To unsubscribe, mail caml-list-request@inria.fr Archives: 
> http://caml.inria.fr
> Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: 
> http://caml.inria.fr/FAQ/
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners




-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners