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",@0→0),("[Integer]",@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",@0→1→0),("Text",@0→1→1)]) λ> present (fromJust (fromList [0])) "hello!"Just (String "String" [("Char",@0→0),("String",@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.