Discussion: adding displayException to Exception class

[Christopher Done]

Well, I think fromList [(1, 'a')] is kind of unhelpful:

   1. It almost never is a straight copy/paste, you will have to go and add
   M. to the fromList.
   2. It doesn’t actually tell you what you’re looking at:

(fromList [(0,'a'),(1,'b'),(2,'c'),(3,'d'),(4,'e'),(5,'f')]
,fromList [(0,'a'),(1,'b'),(2,'c'),(3,'d'),(4,'e'),(5,'f')]
,fromList [1,2,3,4,5]
,fromList [1,2,3,4,5])

What are you looking at?

Answer:

> import qualified Data.Map as M
> import qualified Data.HashMap.Strict as HM
> import qualified Data.Vector as V
> import qualified Data.Vector as S
> (M.fromList (zip [0..5] ['a'..])
  ,HM.fromList (zip [0..5] ['a'..])
  ,S.fromList [1..5]
  ,V.fromList [1..5])

It’s true that numbers (Int/Integer) get a free pass on this, but
I consider those an exception. I’d prefer (if we’re restricting
ourselves to strings) something like

Map [(0,'a'),(1,'b'),(2,'c')] StrictHashMap [(0,'a'),(1,'b'),(2,'c')]
Set [0,1,2,3,4,5]Vector [0,1,2,3,4,5]

But this is not the status quo and I don’t see it changing
soon. People are set on the “looks like code” idea more than “describe
the data structure”.
------------------------------

Digression:

While we’re on the subject, I’d like to be able to convert any Haskell
value to a
Presentation
<http://hackage.haskell.org/package/present-1.1/docs/Present-Types.html>
which
IDEs and browsers can use to trivially expand data structures lazily,
like this:

λ> present (fromJust (fromList [0])) [1..5]Just (List "[Integer]"
[("Integer", at 0→0),("[Integer]", at 0→1)])
λ> present (fromJust (fromList [0,0])) (T.pack "hi")Just (Char "Char" "'h'")
λ> present (fromJust (fromList [0,1])) (T.pack "hi")Just (String
"Text" [("Char", at 0→1→0),("Text", at 0→1→1)])
λ> present (fromJust (fromList [0])) "hello!"Just (String "String"
[("Char", at 0→0),("String", at 0→1)])
λ> present (fromJust (fromList [0,0])) "hello!"Just (Char "Char" "'h'")
λ> present (fromJust (fromList [0,1,0])) "hello!"Just (Char "Char" "'e'")

Video of Emacs taking advantage of this output.
<https://www.youtube.com/watch?v=oJhIvHtflbI>

And to be able to choose *how to present* the structure. E.g. if I
wanted, I could present a Set like:

{0 1 2 3 4 5}

and a Map like:

{ 0 => 'a', 1 => 'b', 2 => 'c' }

and, let’s say I add a Tree constructor to the Presentation type,
i.e. a known “tree-ish” structure, then I can render a Data.Tree like:

         {0 1 2 3}
        /         \
    {4 5 6}     {7 8 9}
       …            …

Where the … is an expansion thing to click. Because Presentation
contains type information, you can hover your mouse or whatever to
inspect the types of things.

But making this work in the general sense has been hard: Show is not
parseable, many data types in real projects are not instances of Data
(and types like Text and Vector have bogus instances). I believe my
only recourse will be using the GHC API to inspect data types or
template-haskell’s reify in an effort to cross module
encapsulation. Now that Typeable is not user-definable, one cannot use
the derive <http://hackage.haskell.org/package/derive> package,
either. I think the :sprint/:print of GHCi is sort of there, but
using it would be more hacky — it would be better to hook into
whatever API is used to produce that feature in GHC and spit out a
Presentation.

In general, it seems the current Haskell state of affairs makes it
tricky to just print a value and expand it incrementally in the same
way that you can in Common Lisp or JavaScript.
​
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/libraries/attachments/20141029/1e6b75bb/attachment-0001.html>