This site is updated infrequently. For up-to-date information, please visit the new OCaml website at ocaml.org.

Re: Let rec trouble
• Pierre Weis
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: -- (:) From: Pierre Weis Subject: Re: Let rec trouble
```> I'm having trouble with the syntax of let rec.  Consider the following
> program for computing Van der Waerden's bound:
>
>   open Num
>   open Nat
>   open Big_int
>   open Ratio
>
>   let rec n k l =
>     let rec m i =
>       if i =/ Int 0 then
>         Int 1 else
>         Int 2
>           */ (m (pred_num i))
>           */ (n (k **/ (m (pred_num i))) (pred_num l)) in
>     if l =/ Int 2 then succ_num k else m k;;
>
>   print_string (string_of_num (n (Int 3) (Int 3)));;
>
> I would like to restrict the lexical scope of 'n' by replacing the first
> double semicolon with 'in.'  I nest m precisely to capture k and l in m's
> lexical environment.  Why is this use forbidden?  I.e. Why shouldn't I be
> able to write:
>
>   let rec n k l =
>     let rec m i =
>       if i =/ Int 0 then
>         Int 1 else
>         Int 2
>           */ (m (pred_num i))
>           */ (n (k **/ (m (pred_num i))) (pred_num l)) in
>     if l =/ Int 2 then succ_num k else m k
>   in
>     print_string (string_of_num (n (Int 3) (Int 3)));;
>
> I would prefer not to define a top level symbol, and this seems an
> inconsistancy.  Am I missing something?
>
> --
> Christopher Oliver                     Traverse Internet
> Systems Coordinator                    223 Grandview Pkwy, Suite 108
> oliver@traverse.net                    Traverse City, Michigan, 49684
> let magic f = fun x -> x and more_magic n f = fun x -> f ((n f) x);;

You're second program is perfectly legal in Caml (and Objective Caml)
and indeed works fine.

The problem (if any) is that this program leads to a huge computation
(the result is an integer number with 50100 decimal digits). Thus it
takes a while to run, and that may be the reason why you thought the
second version did not work properly: in the first version, when
defining the n function first you had not to wait for any
computation. You just have to wait for the answer when evaluating
print_string (string_of_num (n (Int 3) (Int 3)));;. On the other hand,
when mixing the final computation and the function definition you had
to wait until the end of the entire computation.

I assume you were using the interactive system, hence your
surprise. If you were writing stand alone programs, the compiler
whould have properly compiled the two versions of your program and you
would never have noticed any problem!

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis/

```