could ghci debugger search for free variables better?

[Peter Hercek]

Simon Marlow wrote:
> We thought about this when working on the debugger, and the problem is 
> that to make the debugger retain all the variables that are in scope 
> rather than just free in the expression adds a lot of overhead, and it 
> fundamentally changes the structure of the generated code: everything 
> becomes recursive, for one thing.  Well, perhaps you could omit all the 
> recursive references (except the ones that are also free?), but there 
> would still be a lot of overhead due to having to retain all those extra 
> references.
> 
> It also risks creating serious space leaks, by retaining references to 
> things that the program would normally discard.
> 
> Fortunately it's usually easy to work around the limitation, just by 
> adding extra references to your code, e.g. in a let expression that 
> isn't used.

Yes, Pepe pointed this to me too along with the "Step inside
  GHCi debugger" paper in monad reader. The problem is that
  I mostly can find out what is wrong when I look at values of
  some important variables when some important place in my code
  is hit. Using the trick with const function to manually add
  references is not that much better than simple "printf
  debugging" (adding Debug.Trace.trace calls to the code).
  Tracing the execution history is nice too but it provides
  much more than what is needed and obscures the important parts.

OK, It is frustrating that I find "printf debugging" often more
  productive than ghci debugger.

I see that it is not a good idea to keep references to all the
  variables in scope but maybe few improvements are possible:

1) As there is :steplocal, there should be also :tracelocal.
    It would keep history of evaluations within given function
    then when user asks for a variable it would be searched
    first in the selected expression and if not found in the
    expressions from the tracelocal history. If the result
    would be printed from tracelocal history it should be indicated
    so in the output. This would avoid the tedious task of
    searching the trace history manually and moreover it would
    limit the history to the interesting parts (so hopefully
    the depth of 50 would be enough). The results from the
    tracelocal history may not be from the expected scope
    sometimes but the same problem is with "printf debugging".

2) I noticed only now that I do not know how to script
    breakpoints. I tried
    :set stop if myFreeVar == 666 then :list else :continue
    ... and it did not work. My goal was to create a conditional
    breakpoint. I also wanted to use it instead of "printf
    debugging" using something like
    :set stop { :force myFreeVar; :continue }
    Ideally it should be possible to attach
    different script for each breakpoint and the functions
    for controlling debugger should be available in the
    Haskell. I would expect this is already partially possible
    now (using :set stop) and possibly some functions from
    ghci api which correspond to ghci commands (like :set etc.).
    But I do not know how, any pointers from experienced ghci
    debugger users?

Ghci debugger did not know some functions in my code which
  I would expect it to know; e.g. field selection functions
  from a record which is not exported from the module but
  which are available withing module. Is this expected?
  (I did not have any *.hi *.o files around when ghci did run
  the code.)

Och and sometimes it did not recognize a free variable in
  the selected expression. The code looked like
  let myFn x = x `div` getDivisor state > 100 in
  if myFn xxx then ...
  the expression "myFn xxx" was selected while browsing trace
  history but xxx was not recognized, but when I browsed into
  myFn definition in the trace log the x (which represented
  the same value) was recognized. Is this expected?

Thanks,
    Peter.