The type in the module

build

#1

Hi everyone
I’ve got a question I can’t understand:

type comp = Inf | Egal | Sup

module type TYPE_ORDONNE =
sig
type t
val compare: t -> t -> comp
end

module Mesurable = struct
class virtual mesurable =
object
method virtual distance: unit -> float
end
end

Implement a module M which is compatible with the signature TYPE_ORDONNE and whose type t corresponds to the type measurable defined in the module Mesurable

I’ve written:
module M =
struct
type t = float
let compare ((a:t),(b:t)) = let c = a -. b in
match c with
|0. -> Egal
| x -> if x < 0. then Inf else Sup
end

Is it right or wrong?
And What does mean “type t corresponds to the type measurable defined in the module Mesurable”?

I will be grateful for any help you can offer


#2

Your exercice seems to ask you to start with

  module M = struct
    class t ... = object inherit Mesurable.mesurable ... end
    ...
 end

which is a bit surprising.


#3

Thank you for your answer.
Is this compatible with the signature TYPE_ORDONNE?
Ive really had difficulty understanding this exercice.


#4

Yes, you can satisfy the two constraints simultaneously.


#5

Like this: ?

module M = struct
class t (a,b) = 
    object
        inherit Mesurable.mesurable
        let distance = a - b
    end
let compare ((a:float),(b:float)) = let c = (new t (a,b))#distance in
    match c with
    |0. -> Egal
    | x -> if x < 0. then Inf else Sup

end


#6

You should first make your code compile, then take the time to think on how to be sure that M implements TYPE_ORDONNE.


#7

Thank you , i’ll do that.
But firstly I’d like to focus on your first response: “class t … = object inherit Mesurable.mesurable … end”.
I’ve stated the language ocaml for a few months, I alwais have difficulty understanding the structure of caml.
If you don’t mind, can you explain me “class t” you wrote? please.

I’ve learnt the structure of class in ocaml like this:
class name paramter1 parameter2 …= object … end;;

What does mean “class t” ?


#8

In this case, class t defines a class named t.
If you wish, you could define first a class, then the type t with

class your_prefered_class_name =  ...
type t = your_prefered_class_name

But this is fact unnecessary, since declaring a class t also defines the corresponding class type and type also named t:

class t = object val v = 0 end
type w = t (* <- this is the type t, here,  t ≡ < > *)
class a: t (* <- this is the class type t, here t ≡ object val v: int end  *)
  = object val v = 1 end 
class b = t (* <- this is the class , here t ≡ object val v=0 end *)

#9

Thanks a lot for your explanation.