[Caml-list] mutually dependent modules

[Caml-list] mutually dependent modules

[Giuseppe Lo Presti]

Hi all,
Let's suppose that we have two mutually dependent modules, a.ml and
b.ml, i.e. in b.ml there is a call like A.f1() and in a.ml there is a
call like B.f2(). The question is how to link these modules? The .cmi
and .cmo compiling process runs ok, but when the linker tries to build
the executable, it stops saying something like:
Reference to undefined global `B'
make: *** [executable] Error 2
Any ideas?
Giuseppe Lo Presti


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

Re: [Caml-list] mutually dependent modules

[Chris Hecker]

>Let's suppose that we have two mutually dependent modules, a.ml and
>b.ml, i.e. in b.ml there is a call like A.f1() and in a.ml there is a
>call like B.f2(). The question is how to link these modules?

You can't.  Caml doesn't support circular references in modules.  Search 
the list for lots of threads and in-depth discussion on this topic.

Chris

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

Re: [Caml-list] mutually dependent modules

[Issac Trotts]

Chris Hecker wrote:

>
>> Let's suppose that we have two mutually dependent modules, a.ml and
>> b.ml, i.e. in b.ml there is a call like A.f1() and in a.ml there is a
>> call like B.f2(). The question is how to link these modules?
>
>
> You can't.  Caml doesn't support circular references in modules.  
> Search the list for lots of threads and in-depth discussion on this topic.
>
> Chris

It's easy to get the desired effect.


let print = print_endline

module A = struct
  let rec f1() = (!f2)(); print "A.f1"
  and f2 = ref(fun () -> ())
end;;

module B =
struct
  let f1 = ref(fun () -> ())
  let f2 () = print "B.f2"
  let f3 () = (!f1)()
end;;

let _ = A.f2 := B.f2
let _ = B.f1 := A.f1
let _ = A.f1()
let _ = print "--"
let _ = B.f3();;

Issac



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

Re: [Caml-list] mutually dependent modules

[cashin]

Issac Trotts <ijtrotts@ucdavis.edu> writes:

...
> let _ = A.f2 := B.f2

I've seen this before, but why is it preferable to this?

  A.f2 := B.f2

There's an article on comp.lang.ml where Xavier Leroy mentions this
syntax as a way to get module initialization code to run ... but I get
the impression that folks are using it when it's semantically
equivalent to the same thing with the "let _ = " omitted entirely.

-- 
--Ed L Cashin            |   PGP public key:
  ecashin@uga.edu        |   http://noserose.net/e/pgp/

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

Re: [Caml-list] mutually dependent modules

[Issac Trotts]

cashin@cs.uga.edu wrote:

>Issac Trotts <ijtrotts@ucdavis.edu> writes:
>
>...
>  
>
>>let _ = A.f2 := B.f2
>>    
>>
>
>I've seen this before, but why is it preferable to this?
>
>  A.f2 := B.f2
>
>
>There's an article on comp.lang.ml where Xavier Leroy mentions this
>syntax as a way to get module initialization code to run ... but I get
>the impression that folks are using it when it's semantically
>equivalent to the same thing with the "let _ = " omitted entirely.
>
I've seen both, but I now avoid the "let _ = " expression because if you 
leave it
out then ocamlc gives a warning when you don't supply all the arguments 
to a
function.  The warning is good to have.

Issac



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

Re: [Caml-list] mutually dependent modules

[Michal Moskal]

On Tue, Feb 18, 2003 at 09:18:49PM -0800, Issac Trotts wrote:
> I've seen both, but I now avoid the "let _ = " expression because if you 
> leave it
> out then ocamlc gives a warning when you don't supply all the arguments 
> to a
> function.  The warning is good to have.

let () = f a b c in
let () = g c in
let () = a := b in
...

but after writing lots of imperative code (using camlgl), I found
regular:

f a b c;
g c;
a := b;
...

clearer.

All you need is to remember priority of ';' WRT if-then, match and so
on.

-- 
: Michal Moskal ::::: malekith/at/pld-linux.org :  GCS {C,UL}++++$ a? !tv
: PLD Linux ::::::: Wroclaw University, CS Dept :  {E-,w}-- {b++,e}>+++ h

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

Re: [Caml-list] mutually dependent modules

[Christophe TROESTLER]

On Tue, 18 Feb 2003, Issac Trotts <ijtrotts@ucdavis.edu> wrote:
> 
> I've seen both, but I now avoid the "let _ = " expression because if
> you leave it out then ocamlc gives a warning when you don't supply
> all the arguments to a function.  The warning is good to have.

Use
	let () = ...
-------------------
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

Re: [Caml-list] mutually dependent modules

[Issac Trotts]

Christophe TROESTLER wrote:

>On Tue, 18 Feb 2003, Issac Trotts <ijtrotts@ucdavis.edu> wrote:
>  
>
>>I've seen both, but I now avoid the "let _ = " expression because if
>>you leave it out then ocamlc gives a warning when you don't supply
>>all the arguments to a function.  The warning is good to have.
>>    
>>
>
>Use
>	let () = ...
>
I only know of one place where that would be needed:

 class foo () =
    let () = frobnicate() in
    object
        ...  
    end

since

 class foo () =
    frobnicate();
    object
        ...  
    end

doesn't work.  Otherwise, what's the point?

Issac

   

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

Re: [Caml-list] mutually dependent modules

[cashin]

Christophe TROESTLER <debian00@tiscali.be> writes:

> On Tue, 18 Feb 2003, Issac Trotts <ijtrotts@ucdavis.edu> wrote:
>> 
>> I've seen both, but I now avoid the "let _ = " expression because if
>> you leave it out then ocamlc gives a warning when you don't supply
>> all the arguments to a function.  The warning is good to have.
>
> Use
> 	let () = ...

Thanks for the advice.  Why is that a good idea?  Right now, it seems
like the let idiom is only helpful in a few specific instances.

-- 
--Ed L Cashin            |   PGP public key:
  ecashin@uga.edu        |   http://noserose.net/e/pgp/

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

Re: [Caml-list] mutually dependent modules

[Issac Trotts]

Christophe TROESTLER wrote:

>On Thu, 20 Feb 2003, Issac Trotts <ijtrotts@ucdavis.edu> wrote:
>  
>
>>Christophe TROESTLER wrote:
>>    
>>
>>>	let () = ...
>>>      
>>>
>>I only know of one place where that would be needed: [...]
>>    
>>
>
>What about the simple example:
>----------------------------------------------------------------------
>print_int
>let f x = x + 1
>----------------------------------------------------------------------
>
>Compiling this gives no warning (like what you mention for let _ =
>print_int).  On the other hand, if one had written
>----------------------------------------------------------------------
>let () = print_int
>let f x = x + 1
>----------------------------------------------------------------------
>
>Please correct me if I misunderstood the intent of your mail.
>
>Cheers,
>ChriS
>
Sure, you're right in this case, but I don't tend to write code that way.
In files it would tend to be something like

let foo() =
        print_int;
        let f x = x + 1 in
        f 3;;
File "foo.ml", line 2, characters 8-17:
Warning: this function application is partial,
maybe some arguments are missing.

On the command line I would break it up with ;;'s:

# print_int;;                                 
- : int -> unit = <fun>
# let f x = x + 1 in f 3;;
- : int = 4

Issac





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