mutually recursive modules

mutually recursive modules

[Jacques Le Normand]

[-- Attachment #1: Type: text/plain, Size: 95 bytes --]

Hello caml-list
is it possible to put mutually recursive modules in different files?
--Jacques

[-- Attachment #2: Type: text/html, Size: 105 bytes --]

Re: [Caml-list] mutually recursive modules

[Daniel Bünzli]

Le 22 mars 08 à 20:22, Jacques Le Normand a écrit :

> is it possible to put mutually recursive modules in different files?

No.

Daniel

Re: [Caml-list] mutually recursive modules

[ketti]

>  > is it possible to put mutually recursive modules in different files?
>
>  No.

Yes.
If you wrap them in functors.

Re: [Caml-list] mutually recursive modules

[Jacques Le Normand]

[-- Attachment #1: Type: text/plain, Size: 534 bytes --]

how would I do that?

On Sat, Mar 22, 2008 at 5:20 PM, ketti <kattlachan@gmail.com> wrote:

> >  > is it possible to put mutually recursive modules in different files?
> >
> >  No.
>
> Yes.
> If you wrap them in functors.
>
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>

[-- Attachment #2: Type: text/html, Size: 1174 bytes --]

Re: [Caml-list] mutually recursive modules

[ketti]

2008/3/23 Jacques Le Normand <rathereasy@gmail.com>:
> how would I do that?
>

You have to factor out the types of the modules.
Lets say we have modules A and B which are mutually recursive.
A needs to know the signature of B and vise verse.

So we define the signatures somewhere visible to both A and B:

module type A_T = sig ... end
module type B_T = sig ... end

Now in A and B we can write something like this:

module MkA = functor (B: B_T) -> struct
  ...
end

And then we can tie it together in a third file:

module MkA = A.MkA
module MkB = B.MkB
module rec A : A_T = MkA(B)
and B : B_T = MkB(A)

Done. ^^ (unless i made mistakes)

Does someone know of a less cumbersome way?

Re: [Caml-list] mutually recursive modules

[rossberg]

"ketti" <kattlachan@gmail.com> wrote:
>
> You have to factor out the types of the modules.
> Lets say we have modules A and B which are mutually recursive.
> A needs to know the signature of B and vise verse.
>
> So we define the signatures somewhere visible to both A and B:
>
> module type A_T = sig ... end
> module type B_T = sig ... end

Note that this only works if the signatures themselves aren't mutually
recursive - which often is the case. Unfortunately, there is no solution
that works in the general case.

- Andreas

mutually recursive modules

[Brendan Miller]

I'm new to ocaml.

My understanding is that the ocaml compiler does not allow for
circular dependancy of modules. What is the design reason for this? I
don't think I've ever seen a language before with this limitation. Is
it just to keep people from writing mutually recursive functions
across modules?

Suppose there are two classes, A and B defined in separate modules.
Does the no circular dependancy rule preclude a doubly linked
relationship between A and B? Let's say I want to create a doubly
linked list with alternating element types.

consider the following code, which fails to compile:

A.mli:

class c :
object
  method set_prev : B.c -> unit
  method get_prev : B.c
  method set_next : B.c -> unit
  method get_next : B.c
end


A.ml

class c =
object
  val mutable m_prev : B.c option = None
  val mutable m_next : B.c option = None

  method set_prev prev = m_prev <- prev
  method get_prev = m_prev
  method set_next next = m_next <- next
  method get_next = m_next
end;;


B.mli

class c :
object
  method set_prev : A.c -> unit
  method get_prev : A.c
  method set_next : A.c -> unit
  method get_next : A.c
end

B.ml

class c =
object
  val mutable m_prev : A.c option = None
  val mutable m_next : A.c option = None
  method set_prev prev = m_prev <- prev
  method get_prev = m_prev
  method set_next next = m_next <- next
  method get_next = m_next
end;;

This is annoying. Of course I need a way to make classes from
different modules recur. Is there a syntax for specifying an interface
to the type I'm recurring with without that type actually being in the
same module? That would be somewhat cumbersome, but would actually
more properly separate the types than the code above.

In general, could someone clarify the rational for making type
recursion so cumbersome?

thx

Re: [Caml-list] mutually recursive modules

[Jacques Garrigue]

From: Brendan Miller <catphive.lists@gmail.com>

> I'm new to ocaml.
> 
> My understanding is that the ocaml compiler does not allow for
> circular dependancy of modules. What is the design reason for this?

In ocaml modules do not only define functions, but also values.
It means that they require computation at initialization time.
If two modules recurse with each other, which one should be
initialized first? What happens when one accesses an uninitialized
value?
C has one answer: no initialization in modules, and (IIRC) random
values when unitialized.
Java has another answer: somewhat arbitrary initialization order, and
each type has a default value.
In ocaml initialization happens, and there are no default values, so
there is no good answer to what should happen with mutual
recursion. So this is prohibited.

> This is annoying. Of course I need a way to make classes from
> different modules recur. Is there a syntax for specifying an interface
> to the type I'm recurring with without that type actually being in the
> same module? That would be somewhat cumbersome, but would actually
> more properly separate the types than the code above.

Yes, you can define interfaces with "class type".
Since class types are "structural", i.e. two identical definitions in
different places are seen as equal, this allows recursion at the type
level.
However, other type definitions (like sums and records) are not
structural, so you cannot move them around. So most people just define
all their exported types in a single module, which can be seen by all
the program. You can avoid it, but this makes life simpler.

Jacques

Re: [Caml-list] mutually recursive modules

[skaller]

On Tue, 2006-01-17 at 19:21 +0900, Jacques Garrigue wrote:

> However, other type definitions (like sums and records) are not
> structural, so you cannot move them around. So most people just define
> all their exported types in a single module, which can be seen by all
> the program. You can avoid it, but this makes life simpler.

Unfortunately, this idea is very nice but doesn't work
with the current Ocaml toolset due to the fact the parser
generates the token type.

-- 
John Skaller <skaller at users dot sf dot net>
Felix, successor to C++: http://felix.sf.net

[Caml-list] mutually recursive modules

[Jonathan Roewen]

Hi,

Can one make mutually recursive modules (inside the one .ml file of course)?

Jonathan

Re: [Caml-list] mutually recursive modules

[Alain Frisch]

Jonathan Roewen wrote:
> Can one make mutually recursive modules (inside the one .ml file of course)?

Yes, see Section 7.9 of the manual.

-- Alain