Hacker News Reader

Comment by CJefferson | Hacker News Reader

Ooo, let's try something functional:

    > map reverse

    No instance for (GHC.Show.Show ([[a0]] -> [[a0]]))
    arising from a use of `M1690418375.show_M1690418375'
    Possible fix:
    add an instance declaration for (GHC.Show.Show ([[a0]] -> [[a0]]))

Hmm....

View on HN

    > :t map reverse
    :: [[a]] -> [[a]]

    > show (map reverse)
    No instance for (GHC.Show.Show ([[a0]] -> [[a0]]))

You can't show functions. Pass an argument:

    > map reverse ["test","this"]
    => ["tset","siht"]

This tells you that "map reverse" returned a function that takes a list and returns a list. This function does not have a "Show" instance (analogous to someone failing to implement the "toString()" method for that type), so an error is thrown at you since it cannot possibly output something that doesn't know how to be output. Try just storing it in a variable instead.

> let f = map reverse

> f [[1,2,3], [6,7,8]]

EDIT: scratch the "let" example (thanks nandemo), tryhaskell.org doesn't support that. my bad!

That works on ghci but, unfortunately, Try Haskell doesn't seem to support let.

TryHaskell uses http://hackage.haskell.org/package/mueval and not ghci You can eval expression so following works let t ="foo" in t

Yeah, I saw that it uses mueval, but it's still conceivable that TryHaskell itself could hack support for let on top of it. Apparently Chris planned to do it [1].

Note that in "let t=bar in foo" the scope of t is restricted to foo, so the example above still doesn't work.

[1] http://www.reddit.com/r/haskell/comments/b58rk/try_haskell/c... ([deleted] = Chris Doner)

Fair enough but you could do let f = map reverse in f ["ab", "cd"]

IMHO the tryhaskell expose more or less only simple pure functions and I doubt that anyone with a real interest in haskell will get any substantial out of it. However if one is completely new to programming maybe TryHaskell and these 6 short lessons have a value.

Agreed.

Incidentally, Chris Doner has been producing far more exciting things like Fay, so I'm not gonna complain about TryHaskell.

I'm not sure what you expected. It's just saying it doesn't know how to print a function that takes as input a list of lists of type a0 and returns a list of lists of type a0.

Try map reverse ["abc", "123"] instead, which it does know how to print.

I don't know what I expected. I don't know Haskell. I am vaguely familiar with other functional languages and thought I would explore. However, this system (or Haskell) are not super-friendly to exploring currying it seems.

As other people are asking, though, what did you expect? Serious question. What you got was perhaps phrased in terms you're not used to, but there's not much else you could have gotten.

I understand curried functions are a very common thing to build in functional languages. So some nicely 'pretty printed' version would be nice. Or at least the least some kind of "can't print a function" in a nice way.

This looks like the kind of thing I get when my C linker has horribly choked on my code, what is the benefit of displaying: M1690418375.show_M1690418375 to the user? What should I do with that piece of information?

How do I 'add an instance declaration for (GHC.Show.Show ([[a0]] -> [[a0]]))'? I'm guessing that this is basically "suggesting" I implement printing for all functions? Or just for map? I'm not sure. I'm sure I'm not doing it, and it may well not even be possible?

I hear you. When I started learning Haskell I was also somewhat frustrated by some error messages. But it's far from an insurmountable problem, if you're really interested in learning the language. My suggestion is,

(i) use ghc and ghci. TryHaskell isn't actively mantained AFAIK.

(ii) if you find a cryptic error message, first google it and learn the immediate fix, without trying to understand all the details. Of course, eventually you'll have to learn the details, but there's no reason it should be a blocking issue in the beginning.

In any case this is my short-ish, inaccurate version of "the details":

1. In the interpreter, there's an implicit "print foo" when you type "foo".

2. "print foo" expects a foo of any type t as long as t is an instance of the typeclass Show, meaning there must be a show function associated with t that turns t's into Strings. Roughly, that would be as if we had a Java where the method toString (=show) is not part of Object, but rather of an interface Showable, which not all classes have to implement.

3. In Haskell, it was decided that function types shouldn't be instances of Show because they don't have a sensible show implementation. In theory you can have a show implementation that prints "this is function" for all functions, but that's of limited usefulness.

4. The compiler's error message is just an instance of a more general message: a value foo is used in a place that expects a type that's an instance of SomeTypeClass, but foo turns out to be of a type T that isn't. For instance, if you try this on ghci:

    >  'a' + 'b'

you'll get a similar error message, because '+' expects 2 arguments of a type that's an instance of typeclass Num, but 'a' and 'b' are of type Char which is not a Num in Haskell. In theory, the compiler could be "hardcoded" to print a special error message when SomeTypeClass happens to be Show, such as "can't print that type". That would be easier for beginners, but would add some complexity to the compiler.

5. The "M1690418375.show_M1690418375" thing is probably an artifact of the way TryHaskell was implemented. In ghci, you simply get this instead:

     arising from a use of `print'

I hope this helps.

try this:

    > let foo = map reverse

As the error message "clearly" says, the result "map reverse" is a function, which doesn't have a printed representation. You might think that all objects would at the minimum have a default printable representation as "[Object 0x011432542]" or something, but they don't. As always with haskell, the idea is to catch mistakes at compile time: in this case, mistakes where you wanted to show something meaningful to the user, but forgot to define how that kind of object should be printed.

Reply on news.ycombinator.com