Version française
Home     About     Download     Resources     Contact us    
Browse thread
Cannot safely evaluate the definition of the recursively-defined module
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Hugo Ferreira <hmf@i...>
Subject: Cannot safely evaluate the definition of the recursively-defined module
Hello,

I hope this is not a beginners questions.
I am trying to reuse code via functors,
however I am getting the following error:

Cannot safely evaluate the definition of the recursively-defined module
(refers to "AA.empty" when implemented as a constant value)

I circumvented the problem by not using a
constant value but a function instead. As I
understand it this may cause run-time errors.
My question is: is their any way to make the
following example work.

Specifically, for the example below is their
any way of indicating to the compiler that
AA.q = ASet.t ?

TIA,
Hugo F.

module type AA =
   sig
     type q
     type t = string

     val compare: t -> t -> int
     val add: t -> q -> q
     val empty: unit -> q
   end

module rec A1 : AA
                  = struct
                      type q = ASet.t
                      type t = string

                      let compare s1 s2 = Pervasives.compare s1 s2
                      let add e s = ASet.add e s
                      let empty _ = ASet.empty
                    end
         and ASet : Set.S with type elt = A1.t
                  = Set.Make(A1)

module type Wrap_A =
   sig
     type t
     type q

     val init: q
     val add: t -> q -> q
   end

module Make_A (An_A : AA) : Wrap_A
  =
  struct
     type t = An_A.t
     type q = An_A.q

     (*let init = ASet.empty*)
     let init = An_A.empty ()
     let add t q = An_A.add t q
end

module Wrap_A1 = Make_A( A1 )