- Is there a place where it is described how to decrypt "trace" output?

Or may be you can tell me what all this mean?

fold <-- <fun>

fold --> <fun>

fold* <-- <poly>

fold* --> <fun>

fold** <--

Node (Node (Leaf, <poly>, Leaf), <poly>,

Node (Node (Leaf, <poly>, Node (Leaf, <poly>, Leaf)), <poly>,

Node (Leaf, <poly>, Leaf)))

What is the difference between fold and fold* and fold**, is it a

reference to 3 different instantiations of the same function?

What is <poly>?

I guess "<--" means parameter in and "-->" - return value?

Are there any other symbols I should be aware of?

Thanks,

MH - On Mon, 6 Aug 2007, cugf_0956 wrote:

> Is there a place where it is described how to decrypt "trace" output?

No. fold* is the function resulting from applying fold to its first

> Or may be you can tell me what all this mean?

>

> fold <-- <fun>

> fold --> <fun>

> fold* <-- <poly>

> fold* --> <fun>

> fold** <--

> Node (Node (Leaf, <poly>, Leaf), <poly>,

> Node (Node (Leaf, <poly>, Node (Leaf, <poly>, Leaf)), <poly>,

> Node (Leaf, <poly>, Leaf)))

>

> What is the difference between fold and fold* and fold**, is it a

> reference to 3 different instantiations of the same function?

argument, and fold** is fold with the first two arguments applied (or

fold* with the next argument applied). For example, consider:

# let rec fib n a b =

if n = 0 then a else fib (n-1) (a + b) a;;

val fib : int -> int -> int -> int = <fun>

# #trace fib;;

fib is now traced.

# fib 3 1 0;;

fib <-- 3

fib --> <fun>

fib* <-- 1

fib* --> <fun>

fib** <-- 0

fib <-- 2

fib --> <fun>

fib* <-- 1

fib* --> <fun>

fib** <-- 1

fib <-- 1

fib --> <fun>

fib* <-- 2

fib* --> <fun>

fib** <-- 1

fib <-- 0

fib --> <fun>

fib* <-- 3

fib* --> <fun>

fib** <-- 2

fib** --> 3

fib** --> 3

fib** --> 3

fib** --> 3

- : int = 3

> What is <poly>?

poly indicates that a value is being passed into a polymorphic parameter

of the function. For example, using your fold function:

# type 'a tree = Leaf | Node of 'a tree * 'a * 'a tree;;

type 'a tree = Leaf | Node of 'a tree * 'a * 'a tree

# let rec fold glue lfval tr = (* Divide/conquer/glue on trees *)

match tr with

Leaf -> lfval

| Node(l,v,r) -> glue (fold glue lfval l) v (fold glue lfval r);;

val fold : ('a -> 'b -> 'a -> 'a) -> 'a -> 'b tree -> 'a = <fun>

# #trace fold;;

fold is now traced.

# let fold' = fold (fun l v r -> l + v + r);;

fold <-- <fun>

fold --> <fun>

val fold' : int -> int tree -> int = <fun>

# #trace fold';;

fold' is now traced.

# fold' 0;;

fold' <-- 0

fold* <-- <poly>

fold* --> <fun>

fold' --> <fun>

- : int tree -> int = <fun>

Note that fold' knows it's getting an int, so its trace shows it getting a

0, but once fold' passes it on to fold (where the type on that argument is

'a, not int), we get <poly> printed as the value.

If you know what types are going into the function, you can use type

annotations to specialize the function and get rid of the <poly>. E.g.:

# let f a b c d e = d;;

val f : 'a -> 'b -> 'c -> 'd -> 'e -> 'd = <fun>

# #trace f;;

f is now traced.

# f 0 1 2 3 4;;

f <-- <poly>

f --> <fun>

f* <-- <poly>

f* --> <fun>

f** <-- <poly>

f** --> <fun>

f*** <-- <poly>

f*** --> <fun>

f**** <-- <poly>

f**** --> <poly>

- : int = 3

# let f' a b (c : int) d e = d;;

val f' : 'a -> 'b -> int -> 'c -> 'd -> 'c = <fun>

# #trace f';;

f' is now traced.

# f' 0 1 2 3 4;;

f' <-- <poly>

f' --> <fun>

f'* <-- <poly>

f'* --> <fun>

f'** <-- 2

f'** --> <fun>

f'*** <-- <poly>

f'*** --> <fun>

f'**** <-- <poly>

f'**** --> <poly>

- : int = 3

> I guess "<--" means parameter in and "-->" - return value?

Yes.

> Are there any other symbols I should be aware of?

Well, I know that there is <obj> for representing objects, but that's all

I can recall. I don't use tracing very often.

William D. Neumann

---

"There's just so many extra children, we could just feed the

children to these tigers. We don't need them, we're not doing

anything with them.

Tigers are noble and sleek; children are loud and messy."

-- Neko Case

Life is unfair. Kill yourself or get over it.

-- Black Box Recorder