Discussion: adding displayException to Exception class

[Andreas Abel]

As you notice, the show functions for collections are implemented 
wrongly, they should print

   Fully.Qualified.Module.fromList [(key,value),...]

High time to repent now and not sin again.

Positive example: 
https://hackage.haskell.org/package/Agda-2.4.0/docs/src/Agda-Utils-BiMap.html#BiMap

On 29.10.2014 23:07, Christopher Done wrote:
> 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.Mapas  M
>>import  qualified  Data.HashMap.Strictas  HM
>>import  qualified  Data.Vectoras  V
>>import  qualified  Data.Vectoras  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.
>
> ​
>
>
> _______________________________________________
> Libraries mailing list
> Libraries at haskell.org
> http://www.haskell.org/mailman/listinfo/libraries
>


-- 
Andreas Abel  <><      Du bist der geliebte Mensch.

Department of Computer Science and Engineering
Chalmers and Gothenburg University, Sweden

andreas.abel at gu.se
http://www2.tcs.ifi.lmu.de/~abel/