Try Haskell: An interactive tutorial in your browser | Hacker News Reader

Try Haskell: An interactive tutorial in your browser

tryhaskell.org

62 pointsniggler38 comments

I have read some tutorials about Haskell (to be completely honest, 60% of "Learn haskell for great good" twice). Still, I need to stop and think for few seconds to write something in it.

It does take a while, but, for me at least, it did eventually become natural.

I've been through this a few times. It puts me off Haskell even more each time.

Bear in mind I'm pretty handy with obscure obfuscated by default things like RPL, Forth and Perl and occasionally common lisp.

> It puts me off Haskell even more each time.

How come?

It's not the tutorial specifically - more Haskell itself:

Syntax feels slightly horrid. Doesn't seem to visually or syntactically scale well with the size of the problem at hand. Some of it is plain ugly (records). It's harder than the others resulting in more head scratching. Debugging is slightly painful.

These are all IMHO.

To be fair, I'm going to do the tutorial again this afternoon.

What do you mean "syntax doesn't syntactically scale" ?

A single function/expression tends to drag over too much space for my liking. It's hard to break down some of them into functional units that fit in my head properly. Perhaps I'm just thick :)

Look at List.hs (sort/sortBy) for what I mean:

http://hackage.haskell.org/packages/archive/base/latest/doc/...

That looks like a very tidy implementation to me.. I think the problem is that because its split into so many helper functions you don't really know where the code is going, but if you follow through I think this code eventually fits in your mind better than an imperative version would.

That sortBy is split into 6 sub-functions, all 2 to 4 lines each. You want it more broken down?

Fair point. I will do the tutorial again! :)

I might get it if I keep trying.

(ironically I did an engineering degree which was rather maths heavy so I should get this).

That is actually really clean code.

Haskell can just take some time to get used to. The code is laid out differently and the use of curried functions and point-free styles can throw you off coming from imperative code.

Make an interactive tutorial for monads. After 5 articles about it, who were all very different, I still don't know how to code one.

Why do you want to code one? Monads are a class of solutions to certain problems. Look at your problem and solve it using regular haskell. Now look at your solution, it might be that the set of functions that define your solution describe a monad. Is this relevant? Usually not, unless you are developing a highly reusable library.

An example: almost every FP course has the students define the Maybe datatype with its accompanying functions. In Haskell Maybe is an instance of Monad, but you don't need to know that to use or make Maybe, it just turns out that the Maybe solution is in that class of Monads.

The majority of monad "tutorials" are notoriously terrible. Have you read "You Could Have Invented Monads! (And Maybe You Already Have.)"? If no, you should try it, it's a rather nice article. If yes, where did you get stuck with trying to implement your own?

Bah, I just noticed I completely forgot to include the link for the lazy: http://blog.sigfpe.com/2006/08/you-could-have-invented-monad...

Look at Parsec to see how powerful monadic code can be. That single-handedly cleared up the issue for me when I was learning Haskell.

http://book.realworldhaskell.org/read/

Obligatory LYAH link :):

http://learnyouahaskell.com/

I gave this book to a lot of programmer friends, and most were very enthusiastic after finishing the book. Even if you never use Haskell in the real world, learning its abstractions makes you a better programmer (and sometimes annoyed by the lack of type system features in other languages ;)).

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....

    > :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.

Throws a bunch of jQuery errors in Firefox Aurora. Works OK in Chrome.

You constructed a list!

Well done, that was tricky syntax. You used the (:) function. It takes two values, some value and a list, and constructs a new list out of them. We call it 'cons' for short.

No it's not:

> 'a' : [] => "a"

What's the problem? A string in Haskell is a list of chars[1]. So you can construct a string by consing chars to an empty list. Or is there something else you object to?

[1] Which incidentally is a reason to avoid using it for anything serious. Text is the better representation of text, and ByteString is better for everything else.

In Haskell "a" is the same as ['a']

As is usually the case with interactive tutorials, unexpected behavior shows up before the clarifying example. Later they show the equivalence of strings "a" and list of chars ['a']

Would you accept:

> 'a' : "" => "a"

Because that's what you did.

Reply on news.ycombinator.com