# The type in the module

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”?

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

which is a bit surprising.

Is this compatible with the signature TYPE_ORDONNE?
Ive really had difficulty understanding this exercice.

Yes, you can satisfy the two constraints simultaneously.

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

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

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” ?

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 *)
``````

Thanks a lot for your explanation.