Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] Functorizing large collections of modules
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Yaron M. Minsky <yminsky@c...>
Subject: Re: [Caml-list] Functorizing large collections of modules
The problem, I think, with the solution listed below is that I don't see
how Bar can refer to Foo easily.  In particular, it seems like every
time Foo.Make(ZZp) references Bar, it really needs to refrence
Bar.Make(ZZp).  And come to think of it, I don't know how to do this at
all, since (I think) every invocation of Bar.Make(ZZp) creates an
independent instance of the module.   

In particular, imagine Foo needs to reference Bar.  Without functors,
the files might look something like this:

    foo.ml:
      
      let _ = Bar.snoo (ZZp.snip ())
    
    bar.ml:
    
       let open = ZZp.bark () + ZZp.flip ()
    
Now, with functors, how would this work?  

    foo.ml:
      
      module M(ZZp:ZZpSig) = 
      struct 
        module Bar = Bar.M(ZZp)
        let _ = Bar.snoo (ZZp.snip ())
      end
    
    bar.ml:
    
       module M(ZZp:ZZpSig) = 
       struct
          let open = ZZp.bark () + ZZp.flip ()
       end

So now foo can refrence bar.  But if there's a different module that
wants to look at bar also, it will end up referencing a different
instance of Bar.M(ZZp), which seems problematic.

So now I'm more confused than ever.

y

On Mon, 2002-03-18 at 04:01, Remi VANICAT wrote:
> "Yaron M. Minsky" <yminsky@cs.cornell.edu> writes:
> 
> > This seems messy and kind of silly.  Conceptually what I want is a
> > single structure like this:
> > 
> > module Library(ZZp:ZZpSig) = 
> > struct
> > 
> >   module Foo = 
> >   struct ... end
> > 
> >   module Bar =
> >   struct ... end
> >   
> >   ...
> > 
> > end
> > 
> > That way, all the interior modules (Foo, Bar) get to reference the same
> > ZZp, without having to functorize the individual modules.  So, what I'd
> > like is to be able to do this without sticking the modules Foo and Bar
> > into the same single large unmanageable file.
> 
> you can call the functor in a bigger functor :
> 
> file foo.ml
> 
> module Make(ZZp:ZZpSig) =
> struct ... end
> 
> file bar.ml
> 
> module Make(ZZp:ZZpSig) =
> struct ... end
> 
> file library.ml
> 
> module Make(ZZp:ZZpSig)=
> struct
>   module Foo = Foo.Make(ZZp)
>   module Bar = Bar.Make(ZZp)
> end
> -- 
> Rémi Vanicat
> vanicat@labri.u-bordeaux.fr
> http://dept-info.labri.u-bordeaux.fr/~vanicat
> -------------------
> 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
> 
-- 
|--------/            Yaron M. Minsky              \--------|
|--------\ http://www.cs.cornell.edu/home/yminsky/ /--------|

Open PGP --- KeyID B1FFD916 (new key as of Dec 4th)
Fingerprint: 5BF6 83E1 0CE3 1043 95D8 F8D5 9F12 B3A9 B1FF D916

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