I'd like to be able to define some polymorphic functions in module
signatures. I explain it right now : I have some abstract modules (this is
not my code, it seems to be a pre-project from Foc) :

module type Set =
sig
  type elem
    
  val (==) : elem -> elem -> bool     
      (* equality *)

  val normalize : elem -> elem      
      (* there may be more than one
	 representation of each element in the set,
	 this function may perform some simplification
      *)

  val print : elem -> unit          
      (* printing (using the Format library) *)
  val write : formatter -> elem -> unit    
      (* writing in file (using the Format library) *)
  val parse : char Stream.t -> elem
  val read : in_channel -> elem
      (* reading from file, compatible with write *)
  val write_bin : out_channel -> elem -> unit  
      (* writing as binary value *)
  val read_bin : in_channel -> elem         
      (* reading as binary value *)
end

module type Group =
sig
  include Set

  val zero : elem
    (* zero ! *)
  val (++) : elem -> elem -> elem         
      (* sum *)
  val (--) : elem -> elem -> elem         
      (* subtraction *)
  val opp : elem -> elem
      (* opposite (0 -- x) *)   
end

module type Ring =
sig
  include Group                         
    
  val one : elem                    
    (* one ! *)
  val t_of_int : int -> elem        
      (* the standard mapping from integer *)
  val ( ** ) : elem -> elem -> elem
      (* product *)
  val conjugate : elem -> elem
      (* conjugate value *)
end

So you see module type Ring implement the "methods" of Group. My problem
is : the exponentiation (x -> x^i for a positive integer) can be
accomplished with just the product, without knowledge of what the objects
are.

Next we define some Rings, filling the holes in the definitions :

module Ring_Z = 
  struct
    type elem = int
    type stathm = int
    let zero = 0
    let one = 1
    let t_of_int n = n
    let (++) = (+)
    let (--) = (-)
    let ( ** ) = ( * )
    let ( == ) = ( = )
    let opp x = - x
    let print = print_int
    let write ch = pp_print_int ch 
    let parse = parse_int
    let read ch = parse (Stream.of_channel ch)  
    let write_bin = output_value
    let read_bin = input_value
    let stathm = abs
    let less = (<)
    let (//) = (/)
    let (mod) = (mod)
    let div_mod x y = x / y, x mod y
    let normalize x = x
    let conjugate x = x
  end

(it's an Euclidian Ring, but that's not the point). So you see my problem
: I have to define a concrete method in an abstract module, just not to
have to fill the definition for every new Ring I define.

Is there a way to do this ? Or is this specific to objects ?

\bye

-- 

                   Nicolas FRANCOIS
            http://nicolas.francois.free.fr
 A TRUE Klingon programmer does NOT comment his code
-------------------
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