On Wednesday 20 August 2003 9:16 am, Bernard James POPE wrote:

If you can live with supporting only one compiler then you can get a lot of this done via the FFI.

In buddha, my debugger for Haskell, I have to print pretty versions of arbitrary data structures, which is in many ways similar to what you want to do.

[details omitted]

This interface looks pretty similar to the interfacein Hugs The module is hugs98/libraries/Hugs/Internals.hs: http://cvs.haskell.org/cgi-bin/cvsweb.cgi/hugs98/libraries/Hugs/Internals.hs?rev=1.2&content-type=text/x-cvsweb-markup&sortby=log It seems to me that, with a little tweaking of the Buddha and Hugs.Internals interfaces, we could provide the same interface on both Hugs and GHC. (It's also pretty simple to implement so it could potentially be added to NHC98 as well.) The major difference between the interfaces is that Buddha's thunk representation is a recursive datatype so the reify operation relies on lazyness to handle cycles and large substructures. Instead, Hugs.Internals thunk representation is a non-recursive datatype and 'classifyCell' (the equivalent of Buddha's reify) is an operation to classify a single thunk as an Int, Float, application, etc. and the program must explicitly traverse function arguments to examine them. This is a pretty small difference - the Buddha-style of interface is easily implemented in terms of the Hugs.Internals interface. Another potential difference is in the semantics. The semantics of the Hugs.Internals operations is difficult because they allow you to examine unevaluated thunks in the heap. For example, you might look at a thunk for: 1+2 and see any of the following: addInt (fromInteger <dictionary> 1) (fromInteger <dictionary> 2) addInt 1 (fromInteger <dictionary> 2) addInt 1 2 3 in fact, a legal (but bizarre) Haskell compiler could also return 4-1 1 + (1+1) id 3 or anything else whose value is 3. To reflect this in the semantics, we use the same trick that we use in the semantics of exception handling and use non-determinism. That is, a thunk is viewed as a set of all possible representations of the same _value_ and classifyCell merely selects one of those representations (which is why classifyCell is in the IO monad). Sadly, the resulting semantics isn't compositional since the semantics of an application e1 e2 contains both 'good' meanings based on the semantics of e1 and e2 [ x y | x <- [[e1]], y <- [[e2]] ] but also many expressions that have nothing to do with the semantics of e1 or of e2 but which just happen to evaluate to the same value (like the legal but bizarre reifications of 1+2 given above). Not having a compositional semantics is frequently regarded as a Bad Thing. -- Alastair Reid ps Hugs.GenericPrint in the same directory contains a generic printing function based on Hugs.Internal that produces output identical to the old Hugs printing mechanism. There's also code (Hugs.CVHAssert) to write assert functions where the assertions are about the size of the arguments (based on an idea by Cordelia Hall) and there's even some code to disassemble bytecode functions. pps I doubt that these modules have been tested in several years - minor bitrot may well have set in.

Things that seem important (to me) are:

- Do you want to observe cycles and or sharing?

Yes.

Of course this is very hard to do because of garbage collection.

Only in the sense that holding onto an object pointer to detect a cycle might cause you to hold onto the object too - causing a space leak. Weak pointers probably play a useful role in solving this but I didn't explore this.

In buddha I observe cycles but not other forms of sharing. To do this I have to be very careful not to cause garbage collection when I'm traversing the heap. I don't remember now whether you can observe cycles using the Hugs internals interface. I _think_ that it was possible but I don't remember.

Yes, Hugs lets you see sharing.. The CVHAssert module makes use of cycle and sharing detection in calculating the heap space consumed by an object. The Hugs interface has: - raw objects of type 'alpha' (i.e., the Haskell type of the object) - object pointers of type 'Cell' (would be better called 'Thunk'?) which provide a layer of indirection to the object. This indirection lets you prod a thunk pointer ni various ways without evaluating the object it points to. These pointers support pointer equality tests with short-circuiting of indirection nodes. - Cell classifications - whether it is an Int, Float, application, thunk, etc.

- Do you want the ability to force thunks or just stop when you see them? The incremental approach of the Hugs interface is nice, but I'm worried that it will make the detection of cycles harder - that's the reason I moved to reify in buddha away from Hugs style. (In buddha I just want to print things up to the extent that they are evaluated when reify is called, I stop when I see a thunk, cycle, nullary constructor).

Detecting cycles is easy in the Hugs interface. You can continue observing below an unevaluated thunk if you wish - just print the name of the supercombinator and keep going (or disassemble the supercombinator if you wish). Or you can force an unevaluated thunk if that takes your fancy. -- Alastair