How to persist DebugView thunks which are not part of the input value

[alt-romes]

Repro Main.hs:

module Main where
import GHC.Debugger.View.Class

data X = X String
    deriving Show

instance DebugView X where
    debugValue _ = simpleValue "T300-X" True
    debugFields (X s) = pure $ VarFields
        [ ("thunkInt", VarFieldValue intThunk)
        ]
      where
        intThunk :: Int
        intThunk = sum [1 .. length s + 99]

main :: IO ()
main = f (X "A")

f :: Show a => a -> IO ()
f action = do
    print action

T300.cabal:

cabal-version:   3.14
name:            T300
version:         0.1.0.0
license:         NONE
author:          Rodrigo Mesquita
maintainer:      rodrigo.m.mesquita@gmail.com
build-type:      Simple

common warnings
    ghc-options: -Wall

executable t300
    import:           warnings
    main-is:          Main.hs
    build-depends:    base, containers
    build-depends:    haskell-debugger-view
    hs-source-dirs:   .
    default-language: Haskell2010

The problem happens if you break on print action, look at action in the variables pane (which uses DebugView), force the thunkInt field of the action, and observe that it displays the right value momentarily, but immediately is cleared to a thunk again.

The "clear" is caused by the invalidate request which is sent whenever a value is forced, triggering a re-draw of the variables.
But re-requesting the variable of the DebugView field should now display the thunk, because the variable has already been evaluated.

I'm going to push a test.

[alt-romes]

Ahhhhh........... I guess this is to be expected when the DebugView field value is not an existing value which is persisted across the calls to debugFields, but is rather just an arbitrary computation.

That also explains why this works fine for IntMaps with lazy values.

Every time we recompute the debug view fields we re-create from scratch that thunk, and it must be forced every time from scratch.

[alt-romes]

Would be interesting to think of a way to fix this.

The real-world example in which this came up was:

instance DebugView ModuleGraph where
  debugValue   _ = simpleValue "ModuleGraph" True
  debugFields mg = pure (VarFields [("$html", VarFieldValue (renderModuleGraphHtml mg))])

where renderModuleGraphHtml :: ModuleGraph -> String.

The problem is that this $html field, when forced, is immediately refreshed and cleared because we re-create the renderModuleGraphHtml computation from scratch.

An easy fix for this is:

-   debugFields mg = pure (VarFields [("$html", VarFieldValue (renderModuleGraphHtml mg))])
+   debugFields mg = pure (VarFields [("$html", VarFieldValue $! renderModuleGraphHtml mg)])

Maybe this is fine. When do we want to preserve the laziness of the subfield anyway? Arguably, only when we are referring to real heap values which are part of the input.

A potential alternative is to provide a way to persist heap values across calls to debugFields. We could probably do this through the Program AST, potentially introducing an explicit allocation operation. Then we need to worry about deallocation.

But if the debugView instance has to be changed to do the explicit allocation, we might as well use $! in the first place.

Again, I don't see where it would be useful to have a lazy field displayed for a value which is fully computed in the debugFields call. Well, unless we want to share work across calls to debugFields.