Presentations in Hell (pretty print any data structure)

[chrisdone]

It occurred to me recently that my adventures in present that I ultimately decided wasn’t tenable in Haskell, might actually be tenable for Hell:

1. Hell only supports built-in types, or user-defined records/variants in the file, meaning Hell is capable of knowing all possible shapes of any runtime value, and be able to print them all, structurally (without Show).
2. This could be used for either a REPL, or —eval type of function, to show any value that a Hell script can conceive of.
3. With a terminal (e.g. brick), web or emacs, one could have an interactive, colourized, lazy expansion of any data structure (including infinite lists) out of the box (think CLIM, SLIME, DevTools or nushell).
4. Built in types being Tree, List, Vector, Map, JSON, tuples, Text, ByteString, Int, etc.
5. A user function like Hell.debug :: a -> Text (note, no type class constraint) is also viable, though would depart from Haskell, so I don’t like it. It would break parametricity which is ugly. Whereas a mere command line flag would be ok.

I was watching a video about NuShell and thought, that kind of interactive display of data is actually quite viable for Hell if I combine the architectural designs from my present package and the helpful limitations of Hell.

[chrisdone]

Exciting! On my branch I have the following working:

data Node = Node { i :: Main.Yarr, label :: [Text] }
data Yarr = Yes | No
main = [
  Main.Node { i = Main.Yes, label = ["OK, go!", Error.error "Nooo", "Done." ] },
  Main.Node { i = Main.Yes, label = ["OK, go!", Error.error "Nooo", "Done." ] }
  ]

with --present, outputs:

ConsP
  (RecordP
     "Main.Node"
     [ ("i", ConstructorP "Yes" Nothing)
     , ( "label"
       , ConsP
           (TextP "OK, go!")
           (ConsP
              (ExceptionP
                 ErrorCall
                 (TextP
                    "Nooo\nCallStack (from HasCallStack):\n  error, called at /home/chris/Work/chrisdone/hell/src/Hell.hs:1455:6 in main:Main"))
              (ConsP (TextP "Done.") NilP)))
     ])
  (ConsP
     (RecordP
        "Main.Node"
        [ ("i", ConstructorP "Yes" Nothing)
        , ( "label"
          , ConsP
              (TextP "OK, go!")
              (ConsP
                 (ExceptionP
                    ErrorCall
                    (TextP
                       "Nooo\nCallStack (from HasCallStack):\n  error, called at /home/chris/Work/chrisdone/hell/src/Hell.hs:1455:6 in main:Main"))
                 (ConsP (TextP "Done.") NilP)))
        ])
     NilP)

With this I can generate a pretty-printed text output, but also a vty-based lazily-browsable interface. When I add a presentation for Value, that will offer a nice way to browse JSON values, too.

[chrisdone]

On my branch I've achieved the following things:

1. Confirmed that brick is capable of handling asynchronous events necessary to evaluate parts of a data structure on the fly.
2. I've built out a basic "object explorer" which is lazy.
3. I put in artificial 100ms timeouts between 'ready' / 'evaluating' and done/cancelled, to simulate slower-to-evaluate thunks.

I would want to re-design slighly the Brick code to be better structured, and I think non-atomic or "non-small" objects should be folded into summaries e.g. "[ .. 5 items .. ]" or "{ 3 fields }", similar to modern Chrome/Firefox's lazy-ish handling of those. I'd also want smarter display of lists as a table, as in Nushell. But I'm mostly thinking about operational aspects/evaluation, rather than layout at the moment.

Another idea was eager evaluation of atomic things, like ints, text, etc. to avoid having to delve just to see simple data.

Here's a video showing what's possible:

Screencast.from.11-05-25.21.46.57.webm

Based on this file:

data Person = Person { age :: Int, name :: Text }
data Node = Node { i :: Main.Yarr, label :: [Text], person :: Main.Person }
data Yarr = Yes | No
main = List.cycle [ -- note: infinite list
  Main.Node { i = Main.Yes, label = ["OK, go!", Error.error "Nooo", "Done." ], person = Main.Person { name = "Chris", age = 23 } },
  Main.Node { i = Main.Yes, label = ["Wibble" ], person = Main.Person { name = "Jerry", age = 32 } }
  ]

[chrisdone-artificial]

Checkout jless for inspiration. https://jless.io/