4 ms·

It's a fair point about Haskell's learning curve. Haskell is different enough from the languages most people have grown up using that--at least in my experienc

by mjcmirr 16y ago

It's a fair point about Haskell's learning curve. Haskell is different enough from the languages most people have grown up using that--at least in my experience--there are times that simply understanding a few lines of code can take minutes. On the other hand, that fact has always seemed to me a mark of why it's worthwhile to persevere: as when you are learning mathematics, things can seem entirely opaque until they 'click', but then you've really made an advance in your understanding. Probably most people are aware of it, but the O'Reilly book _Real World Haskell_ by Bryan O'Sullivan, Don Stewart, and John Goerzen, is a great way to get started. The book is on-line at http://book.realworldhaskell.org/ http://book.realworldhaskell.org/ Chapter 8 discusses (one of) the Haskell regexp implementation(s), and in particular addresses one of the puzzling aspects: polymorphism in return type. The whole book is excellent. (I should also point out that another book _Learn You A Haskell_, has just been published, and is well-regarded. I think it assumes rather less programming experience than RWH, and also covers less of the "real-world" aspects. It also can be read on-line, at http://learnyouahaskell.com/ http://learnyouahaskell.com/ and in fact there is a coupon code on that page now for 40% off.) Also, the Haskell community is, in my experience, extremely helpful and welcoming. People should come and join!

pjscott 16y ago
The place where I've seen Haskell really shine is parsing. Parsers are remarkably easy to write in Haskell, thanks to Parsec and its various spinoff libraries. For example, here's a minimal HTTP request parser that Bryan O'Sullivan wrote by essentially translating part of the RFC into Haskell: https://bitbucket.org/bos/attoparsec/src/tip/examples/RFC2616.hs https://bitbucket.org/bos/attoparsec/src/tip/examples/RFC261... It's 54 lines long, pretty trivial, and here's a really cool part: it parses incrementally on strict bytestrings, so you can just do raw socket recv calls and pass the chunks of input to the parser. Similarly, I wrote a parser for the subset of YAML that beanstalkd uses (as part of the hbeanstalk client library), and it was just 11 lines of code. It's very impressive. (The concurrency and parallelism stuff is also notably slick, but I haven't had as much occasion to use it. Haskell's aversion to side-effects really pays off sometimes.) By the way, you're right about the Haskell community being friendly and welcoming -- as you yourself demonstrate. :-)
- alavrik 16y ago
  The HTTP request parser doesn't look readable or trivial to me at all. I'm not familiar with Haskell, so to me the code looks like a mix of high-level declarative and low-level specialized constructs (e.g. skipWhile, takeWhile) interleaved with syntax noise. And it seems to be using quite a lot of external libraries. Also, correspondence of the code with the HTTP spec is completely non-obvious. In contrast, here's an HTTP response parser I wrote in OCaml using just one library: https://github.com/alavrik/piqi/blob/master/piqi-tools/piqi_http.ml https://github.com/alavrik/piqi/blob/master/piqi-tools/piqi_... (see lines 26 - 218). I've just noticed that the code you are referring to is an example. Well, looking at the example, I can hardly come to a conclusion that Haskell shines for parsing.
  - pjscott 16y ago
    If you don't know Haskell, and you've never used attoparsec, then I'm not surprised that you don't find that code to be particularly clear or readable. Haskell has a steep learning curve, as I said earlier. This is not a very damning criticism of Haskell's suitability for writing parsing code. By the way, that long import list is actually just importing some basic stuff from the standard library, and the attoparsec parsing library. One of the persistent minor annoyances of Haskell is writing long lists of module imports.
    - alavrik 16y ago
      Fair enough. I didn't mean to criticize Haskell. In fact, I'm planning to learn it. I was just surprised that this code was presented as a good example of Haskell's fit to the parsers domain. It would be interesting to see if my perception of this code changes once I get more familiar with the language.
      - pjscott 16y ago
        Ah, okay, I misunderstood you. Yes, I think your perception of the code will change. In particular, the operators from Control.Applicative (the ones that look especially like line noise) are critical to making heads or tails of it. When I posted that link, I momentarily forgot that they're not obvious. They make sense after you've used them for a little while, though.
jimmyjazz14 16y ago
Haskell takes the complex and tames it with a wonderful type system and sensible abstractions; personally I have never been more productive using any other language.
gtani 16y ago
shd point out therre's lots of other resources e.g. Graham book, school of Expression, etc (and for all the folks that have been doing scala, ocaml, erlang, F#, some of te concepts will be familiar http://stackoverflow.com/questions/16918/beginners-guide-to-haskell http://stackoverflow.com/questions/16918/beginners-guide-to-... http://stackoverflow.com/questions/1012573/how-to-learn-haskell http://stackoverflow.com/questions/1012573/how-to-learn-hask...

by mjcmirr 16y ago

pjscott 16y ago

The place where I've seen Haskell really shine is parsing. Parsers are remarkably easy to write in Haskell, thanks to Parsec and its various spinoff libraries. For example, here's a minimal HTTP request parser that Bryan O'Sullivan wrote by essentially translating part of the RFC into Haskell: https://bitbucket.org/bos/attoparsec/src/tip/examples/RFC2616.hs https://bitbucket.org/bos/attoparsec/src/tip/examples/RFC261... It's 54 lines long, pretty trivial, and here's a really cool part: it parses incrementally on strict bytestrings, so you can just do raw socket recv calls and pass the chunks of input to the parser. Similarly, I wrote a parser for the subset of YAML that beanstalkd uses (as part of the hbeanstalk client library), and it was just 11 lines of code. It's very impressive. (The concurrency and parallelism stuff is also notably slick, but I haven't had as much occasion to use it. Haskell's aversion to side-effects really pays off sometimes.) By the way, you're right about the Haskell community being friendly and welcoming -- as you yourself demonstrate. :-)

alavrik 16y ago
The HTTP request parser doesn't look readable or trivial to me at all. I'm not familiar with Haskell, so to me the code looks like a mix of high-level declarative and low-level specialized constructs (e.g. skipWhile, takeWhile) interleaved with syntax noise. And it seems to be using quite a lot of external libraries. Also, correspondence of the code with the HTTP spec is completely non-obvious. In contrast, here's an HTTP response parser I wrote in OCaml using just one library: https://github.com/alavrik/piqi/blob/master/piqi-tools/piqi_http.ml https://github.com/alavrik/piqi/blob/master/piqi-tools/piqi_... (see lines 26 - 218). I've just noticed that the code you are referring to is an example. Well, looking at the example, I can hardly come to a conclusion that Haskell shines for parsing.
- pjscott 16y ago
  If you don't know Haskell, and you've never used attoparsec, then I'm not surprised that you don't find that code to be particularly clear or readable. Haskell has a steep learning curve, as I said earlier. This is not a very damning criticism of Haskell's suitability for writing parsing code. By the way, that long import list is actually just importing some basic stuff from the standard library, and the attoparsec parsing library. One of the persistent minor annoyances of Haskell is writing long lists of module imports.
  - alavrik 16y ago
    Fair enough. I didn't mean to criticize Haskell. In fact, I'm planning to learn it. I was just surprised that this code was presented as a good example of Haskell's fit to the parsers domain. It would be interesting to see if my perception of this code changes once I get more familiar with the language.
    - pjscott 16y ago
      Ah, okay, I misunderstood you. Yes, I think your perception of the code will change. In particular, the operators from Control.Applicative (the ones that look especially like line noise) are critical to making heads or tails of it. When I posted that link, I momentarily forgot that they're not obvious. They make sense after you've used them for a little while, though.

jimmyjazz14 16y ago

Haskell takes the complex and tames it with a wonderful type system and sensible abstractions; personally I have never been more productive using any other language.

gtani 16y ago

shd point out therre's lots of other resources e.g. Graham book, school of Expression, etc (and for all the folks that have been doing scala, ocaml, erlang, F#, some of te concepts will be familiar http://stackoverflow.com/questions/16918/beginners-guide-to-haskell http://stackoverflow.com/questions/16918/beginners-guide-to-... http://stackoverflow.com/questions/1012573/how-to-learn-haskell http://stackoverflow.com/questions/1012573/how-to-learn-hask...