caml-list - the Caml user's mailing list
 help / color / mirror / Atom feed
From: "Hawkins, Thomas" <thomas.d.hawkins@medtronic.com>
To: <caml-list@inria.fr>
Subject: [Caml-list] Undefined_recursive_module
Date: Mon, 26 Jul 2004 20:23:06 -0500	[thread overview]
Message-ID: <CC62E8B84E918E438D0BA094D9AF417903D5E3D2@MSPM1BMSGM12.ent.core.medtronic.com> (raw)

I just started experimenting with recursive modules, but have hit a snag with Undefined_recursive_module.

Basically I need to define an ADT where the data structure contains Sets and the Set elements reference back to the data structure.  In the following example, the mutually recursive modules include the main data structure (Process), an ordered type (Files), and a set (FileSet returned from the Set functor).

Both the Process and the File modules define only function values, therefore I believe the example satisfies the "safe module" requirement.  It does compile and run for one case (see does_work).  However, if I make multiple calls to Process.add_file, Undefined_recursive_module is raised (see does_not_work).

Any suggestions?  (I'm using 3.08.0)

Thanks,

Tom






module rec Process :
  sig
    type t
    val create    : unit -> t
    val add_file  : File.t -> t -> unit 
    val print     : t -> unit
  end
  =
  struct
    type t = { mutable files : FileSet.t }
    
    let create () =
      { files = FileSet.empty }

    let add_file file process =
      process.files <- FileSet.add file process.files

    let print process =
      FileSet.iter File.print process.files
  end

and File :
  sig
    type t
    val compare   : t -> t -> int
    val create    : Process.t -> string -> t
    val print     : t -> unit
  end
  =
  struct
    type t = Process.t * string

    let compare a b =
      match a, b with (_, a), (_, b) -> String.compare a b

    let create process name =
      process, name

    let print (_, name) =
      print_string name;
      print_newline ()
  end

and FileSet :
  Set.S with type elt = File.t
  =
  Set.Make(File)
;;



let does_work () =
  let p = Process.create () in
  Process.add_file (File.create p "file1") p;
  Process.print p
;;


let does_not_work () =
  let p = Process.create () in
  Process.add_file (File.create p "file1") p;
  Process.add_file (File.create p "file2") p;
  Process.print p
;;


(*
does_work ();;
*)
does_not_work ();;

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


             reply	other threads:[~2004-07-27  1:23 UTC|newest]

Thread overview: 7+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2004-07-27  1:23 Hawkins, Thomas [this message]
2004-07-27  7:22 ` Alain Frisch
2014-09-10 20:32 [Caml-list] Undefined recursive module Yotam Barnoy
2014-09-10 22:20 ` Jeremy Yallop
2014-09-10 22:26   ` Yotam Barnoy
2014-09-10 22:50     ` Jeremy Yallop
2014-09-10 23:16       ` Yotam Barnoy

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=CC62E8B84E918E438D0BA094D9AF417903D5E3D2@MSPM1BMSGM12.ent.core.medtronic.com \
    --to=thomas.d.hawkins@medtronic.com \
    --cc=caml-list@inria.fr \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).