What I Wish I Knew When Learning Haskell

http://dev.stephendiehl.com/hask/#%281%29

by gtani • 13 years ago

306 99 13 years ago

dev.stephendiehl.com

mercurial• 13 years ago

Pretty comprehensive (including plenty of things I haven't had time to look at into more details yet). Bonus points for using applicative style, which makes it a lot easier (and clearer) to apply function to value inside monads.

cies3• 13 years ago

I think these 3 slides really stand out, they show with how little code one can write serious software in Haskell...

1. ACID (acid-compliant persistance on Haskell data types, with indexes)

http://dev.stephendiehl.com/hask/#(27)

2. Pipes (program on streams of data)

http://dev.stephendiehl.com/hask/#(30)

3. Scotty (micro web-framework, a la Sinatra or Flask, on top of the super fast Warp server) http://dev.stephendiehl.com/hask/#(32)

cscheid• 13 years ago

About your point 3), it's worth noting the "toHtml" call buried in that example.

Haskell is both strongly and statically typed. That type boundary between strings and HTML output is enforced by the compiler, and it automatically (and provably!) prevents a metric crapload of injection attacks.

tel• 13 years ago

To bring this into sharper detail, notice that there's the "OverloadedStrings" compiler directive at the top of the file. That means that "hello " and "!" are of type Html, different from String. Strings can only be concatenated with Html after they've been escaped.

For more elaboration, see http://blog.moertel.com/posts/2006-10-18-a-type-based-soluti...

freyrs34• 13 years ago

Here's an example that brings together Aeson, Lens, Acid-State and Scotty together in one file. Haskell really does have some great offerings for building very solid and fast web applications.

[1] https://github.com/sdiehl/haskell-warp-rest/blob/master/serv...

drhodes• 13 years ago

That url is 404, maybe this is the one?

https://github.com/sdiehl/haskell-warp-rest/blob/master/warp...

avital• 13 years ago

Can acid-state be ported to Javascript?

arianvanp2• 13 years ago

you could try cross-compiling it with Fay or UHC (haskell to javascript compilers)

cies3• 13 years ago

Maybe but it does not seem very obvious to do so to me.. I guess one is better off with using JS's localStorage from Fay[1] or Sunroof[2].

1. http://fay-lang.org

2. https://github.com/ku-fpg/sunroof-compiler/wiki/Tutorial

mercuryrising2• 13 years ago

He's got some good stuff on his website (didn't get much from the slides as I've only dabbled in Haskell a couple times).

http://www.stephendiehl.com/posts/essential_haskell.html

http://www.stephendiehl.com/posts/types.html

sid6376• 13 years ago

Can anyone point to a similar list for Scala? I am just getting started in Scala and would love such a list.

egeozcan• 13 years ago

I would suggest these for the starters: http://shuklan.com/haskell/

mercuryrising2• 13 years ago

Wow those are some awesome lectures. Thanks!!

sordina4• 13 years ago

This is very good. I'm getting a bunch of new tricks out of this even though I regularly use these libraries.

kzrdude3• 13 years ago

Some of the slides need explanation.

What is the value of -ddump-simpl as shown here? http://dev.stephendiehl.com/hask/#%2816%29

freyrs34• 13 years ago

It dumps the internal Core representation of expression. It's closer to the lambda calculus ( System F ) and a good way to understand internals.

ufo2• 13 years ago

As freyrs points out, GHC "desugars" all Haskell code into a very small intermediate language that is similar to the System F lambda calculus. In the slide you linked you can kind of see that: you start with two doubles for 2 and 3 (created wit the `D#` function) and then you add them with the addition operator. Notice that this exposrs the implementation of typeclasses: the overloaded + operator is actually a function of three arguments and the first argument is the "vtable" that has the actual number operations.

I don't know why he is doing all of this though. The slides themselves don't give much context...

pervycreeper• 13 years ago

Is there a recording of a talk to match these slides?

yummyfajitas• 13 years ago

There is a great point buried in slide 8. The best way to learn to use monads is...Use monads in real code.

theicfire• 13 years ago

Recording would be great! I feel like I only got half of the (good) information without it.

Kiro• 13 years ago

I'm a PHP developer and I didn't understand one single thing in this presentation. Any reason I should learn Haskell?

archivator• 13 years ago

Functional programming is a tool. It's a really powerful tool. Knowing really powerful tools helps you solve really difficult problems.

Whether it's Haskell or some other purely functional language, I'm of the opinion that every programmer should have one in their toolset.

kzrdude3• 13 years ago

It's more than a tool, it's a different programming paradigm. It helps you to look at something in a different way. You can pick up a thing or two that are useful pracitices in other imperative programming languages, too.

tkahn6• 13 years ago

Start here:

http://learnyouahaskell.com/chapters

This is good too, but I found it somewhat dry:

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

I think that learning Haskell will make you a better programmer. It's really a different way of doing things.

xaritas• 13 years ago

If you maintain code that is a gigantic ball of if-foreach-else-switch-is_null or your class hierarchy looks like something a Java developer would produce, and you are constantly thinking "there must be a better way," you might benefit from exploring Haskell or a language with some of its features.

PHP is actually one of those languages, since it gained real support for first-class functions, anonymous functions and closures starting with 5.3 and improving with 5.4. So if you do learn Haskell you'll be able to directly apply some of its ideas to making your PHP more concise, easier to test, and less error prone. Check out the PHP Underscore library to provide some of the infrastructure: http://brianhaveri.github.io/Underscore.php/

Haskell brings a lot more to the table than first class functions, and it may or may not be a good introduction to functional programming for you, but other functional(-ish) languages such as Scala or Clojure (or Scheme & other Lisps) will work well, too. Just give it time. It's worth the effort, but you're not going to magically transform your code into the Unicorn Monad overnight.

If you do PHP you probably do a lot of JavaScript, too, so there is another language that supports getting into functional programming, and there is definitely a lot of interest in moving JavaScript in more classically functional direction. So you won't be blindsided by maps, folds and promises.

I apologize if you already use first class functions like a boss and you were really asking if you needed static type inference. The answer is Maybe.

marshray5• 13 years ago

Learn Haskell if you want your mind blown. It will make you smarter.

But there's a real danger that you will not be able to look at your own code the same way again. It can negatively affect your ability to code with your peers.

I'm not kidding. It's a blue pill/red pill kind of thing.

z3phyr• 13 years ago

Nope. I see no negetive effects.

Functional programmers can write better OO code imho.

MichaelGG• 13 years ago

If you're really happy and think things are dandy and don't really have an alternative, then no, stay away from Haskell and FP. As others have commented, you will not be able to code the same way after you have learned functional programming.

While FP doesn't solve everything, it does massively reduce the amount of code you write. Where I work, I started writing everything I owned in F#. After a while, I noticed all other new projects were being written in F#, even by people that had previously told me "we are sticking with C#". Why? Because they feel bad having to write loads more code to get the same work done.

Every time I have to work in C#, I'm constantly annoyed about how verbose even the tiniest things are, how much work there is.

Beware, PHP's syntax for lambdas is incredibly verbose (and IIRC there are some odd limits on how you can use them), so if you become "enlightened" then continue to try to apply it in PHP, you are in for a rough ride. Even C# which slightly embraces functional concepts, gets pretty nasty if you write in any sort of real FP style.

boothead2• 13 years ago

Where do you work that you can just take a decision like "I'm going to use language X" if you don't mind me asking?

How did you deal with concerns (which I assume your manager must have had) about skilling up the rest of your team, and your increasing component of the bus factor? [1]

I tried to make a case for F# for some parts of our codebase and got shot down!

[1] http://en.wikipedia.org/wiki/Bus_factor

drostie• 13 years ago

It's hard to identify a practical reason because presumably using your existing PHP stack is going to be easier for you than learning how to run a Haskell stack. Every new language comes with such barriers. It's sometimes hard to see how severe those barriers are -- I remember trying to show a totally novice-to-programming kid how to set up EasyPHP so that they could start coding. Setting up EasyPHP, which is, well, Easy, requires explaining what HTTP is and what Apache is and all that... it's actually a huge barrier to entry for a novice programmer.

But if you're OK with the impractical, here goes:

Haskell trains you to think about programming in a couple of subtly different ways that change your entire perspective.

(1) Variables are replaced with definitions and values. You probably remember HTTP as stateless and cookies as a sort of informal "patch" for this; similarly it's hard to define state in Haskell. This means that `x = [1, 2, 3];` is allowed but `x[1] = 5;` is not, because the list cannot be directly modified. This does not actually weaken the language because you can always bind new names to new values, and idiomatically you'd often use recursion -- when you want to change a parameter you arrange the code so that you can recurse and call the function again with a new parameter. It's not 100% practical but let's take the Fibonacci numbers, which you might code in PHP like so:

    function fibs($n) {
        $curr = 0; $next = 1;
        for ($i = 0; $i < $n; $i++) {
            $tmp = $curr;
            $curr = $next;
            $next += $tmp;
        }
        return $curr;
    }

In Haskell you could write this itero-recursively as:

    let fibs n = f n 0 1
      where f n curr next = if n < 1 then curr else f (n - 1) (next) (curr + next)

Notice that there's no $tmp and the named variables are now function arguments. You'll find yourself writing PHP more like:

    function fibs($n, $curr = 0, $next = 1) {
        return n < 1 ? $curr : fibs($n - 1, $next, $curr + $next);
    }

(2) Haskell is lazy. The above is actually impure because it implements `fibs` as a function when really the Fibonacci numbers are a sequence and should be treated that way. Haskell actually has no problem with defining the infinite list of Fibonaccis as:

    fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

That's a list just like any other in Haskell, it just happens to be infinite. Or, you can write the infinite list of primes:

    primes = 2 : filter prime [3..]
      where prime k = all (\n -> mod k n /= 0) (takeWhile (\n -> n^2 <= k) primes)

You will miss this a little in other languages; even Python, which can do this with custom generators, gets a little clumsy. Especially, I miss this in Node.js, where the whole language is built around an idea of "callbacks" which wouldn't need to exist if the JavaScript operators could work on deferred computations (sometimes called "promises").

(3) Haskell has a type system and explicit pattern-matching. This is a little harder to express: you're used to saying `x = my_object->x` in PHP to avoid saying "x" over and over. Let's say that the object should also have "y" and "z" fields; then you'll have to deal with cryptic errors if your function is ever called with a my_object which does not have a field named "x", but it will be okay if "y" or "z" is not allowed, even though that doesn't actually make sense really!

In Haskell you'll specify in the definition of the argument "Object x y z"; and then x, y, pattern-matching to those respective values. So your functions don't start off with a bunch of "data-extraction" commands; those commands are in the input pattern. You can also define the function when the patterns do not match, because you can define a function several times for different patterns.

The type system can also flag, for example, unsanitized text going into a SQL query and other such things you might have missed, so you can lean on it a surprising amount.

(4) The biggest thing that this page was talking about was monads, and the reason why it was talking about them is because Haskell offers a special notation for dealing with monads.

A monad is basically a context which you can't necessarily "break the data out of". For example, the "IO" monad is a context which says "this data depends on an unrepeatable IO action, like getting a random number or reading a file." You can't really erase that fact from the data, but that fact shouldn't stand in the way of handling the data. The IO monad allows you to very cleanly separate the stuff which might be different in two different runs of the program, from the stuff which is never so.

The author makes the claim that analogies are bad for understanding monads. Instead, you should just look at the definition. A monad is a typeclass which wraps another type, so the type is "M(T)" where T is any other type. A monad is defined by two functions. One is called "return" and has type T -> M(T), it puts plain data into the monad. The other function is called "bind" and accepts a function T -> M(T2), which intuitively "takes the data and feeds it to the function." The reason that you can't always "break out" of the monad is that the output of this function is M(T2), so the function output must also be in the monad. We know that "monad" is a scary-sounding word but really nobody has a better name for it.

Lists are a good monad; here `return x = [x]` and `bind xs f = concat (map f xs)`. Another simple monad is called Maybe, which can either be `Just x` or `Nothing`, it sort of represents a computation which might fail. Here `return x = Just x` and `bind Nothing fn = Nothing; bind (Just x) fn = fn x`. There's also a "State" monad, which gives you a "put" and "get" method and a scope block for typed modifiable variables, so you can have code that looks imperative -- but you've got to carefully mark it as such with the type system as a whole. The whole point being that once you allow that "put" statement you make it much harder to think about bugs because the value of the parameter will depend on where in the function that parameter appears -- so the type system acts as a warning flag.

thomasjames2• 13 years ago

Does anyone know the best book for learning Haskell? I have heard it is good for just thinking about programming in new ways and keeping your mind agile. I can really only learn a language with a good structured book with exercises at the end of each chapter. Haven't found something definitive yet, but would be open to suggestions.

jimmyjazz14• 13 years ago

I think "Real World Haskell" is great. If you want a more simple introduction checkout "Learn You a Haskell for Great Good!".

ericssmith2• 13 years ago

The 'best' introductory book for learning Haskell is Graham Hutton's 'Programming in Haskell'. It focuses on the essentials of the language, and its clear, spare presentation is in the spirit of Haskell itself. And it is accessible to everyone.

jhickner• 13 years ago

+1 for this, also check out Graham's io9 video on the Counting Problem. The solution is beautiful and really got me excited about Haskell when I was first learning:

http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Func...

thomasjames2• 13 years ago

I was actually thinking of going with this since it seemed to focus on the foundations of lambda calculus and is also fairly condensed. I was thinking I might try "The Haskell School of Expression: Learning Functional Programming through Multimedia" as a follow up just cause it sounded satisfying.

ufo2• 13 years ago

This (now closed) Stackoverflow question is a great resource:

http://stackoverflow.com/questions/1012573/getting-started-w...

Personally, I would agree with the guy that said that Learn You a Haskell and Real World Haskell are some of the best resources. LYAH is really good at explaining the language features while RWH is currently the best we have in terms of giving practical examples with real libraries and things like that.

lobster_johnson3• 13 years ago

Slides don't work in Sarari on iOS. Is there a static version?

Evbn• 13 years ago

This is a tech forum. We do cool new stuff, not make stuff accessible to a wide audience using ancient technology from last week.

lobster_johnson3• 13 years ago

iOS is ancient technology now? Is that why you [or whoever] downvoted me? What the hell?

freyrs34• 13 years ago

http://dev.stephendiehl.com/hask/flat.html

lobster_johnson3• 13 years ago

Finally a proper answer. Thanks!

rtpg• 13 years ago

I disagree completely with his analysis on monads.

If you just present the abstract structure, you cannot understand why you even want (for example) the do notation as a language-level concept. I think this is more of a case of bad examples than anything.

Trying to represnent monads via analogy works badly too though, because monads as used in haskell are more about programming pragmatics than modelling real world objects.

The way to explain it should be :

- Show real code

- Explain why we use this structure to write our code .I think a good explanation is to ...

in Jquery you do things like chaining to build things.

$('selector').css('color','red').filter(someFilter).css('color','blue')

Chaining APIs are useful because you're combining computation('chaining'), and you don't want to have to carry around a value everywhere. You want to do the same thing in Haskell obviously.

Haskell doesn't have dot notation, so you can't do this style exactly. First idea would be to do something like

let x=jQuery document selector in let y=css x 'color' 'red' in let z=filter y someFilter in ...

This is a pain, especially considering that the 'chaining' here is mechanically obvious

let [n+1] = f [n] [whatever] in let [n+2] = g [n+1] ....

So monads, in the most pragmatic sense, allow you to represnt this form of computation. You end up with

jQuery 'selector' >>= css 'color' 'red' >>= filter someSelector >>= css 'color' blue'

You implicitly carry around your computation.

)

In any case the Maybe monad is the worst example ever, just like how a singleton group is a bad example. Sure it's the 'simplest' , but it's far from the most typical

freyrs34• 13 years ago

The problem with bringing jQuery into the discussion is that it's not a monad. Don Stewart explains this more elegantly than I can [1] but the crux of the argument is that chaining together computations is not enough to be a monad, one needs to prove that the monad laws hold.

[1] http://stackoverflow.com/questions/10496932/is-jquery-a-mona...

sordina4• 13 years ago

The majority of the 'proofs' I've seen that jQuery isn't a monad seem to either be probabalistic, or use the "Burden of Proof" argument to show that since nobody has proved that jQuery is a monad, we should assume that it isn't. I agree that jQuery probably isn't a monad, but it rubs me the wrong way that people aren't willing to say "It has yet to be determined if jQuery is a monad".

Obviously it is trivial to show that it isn't a monad by the fact that javascript permits any action in pure code, but by the same token, unsafePerformIO proves that Haskell has no monads. I think it's fair to operate under a reasonable subset of jQuery functionality when asking the question.

tome3• 13 years ago

Maybe is not the simplest monad, Identity is, and I think Maybe is an excellent example of a monad.

TheCoelacanth• 13 years ago

Identity is simpler, but it's not very interesting. It's hard for a beginner to see why you would ever use the Identity monad.

Maybe is the simplest interesting monad, which makes it a good candidate for explaining monads to beginners.

sordina4• 13 years ago

I'm not sure you actually disagree with his method of learning monads.

He primarily advocates for avoiding the use of analogies, which you seem to agree with. He advocates using concrete monads in real code, which you also seem to agree with.

The only contentious point might be learning typeclasses and how monads fit into the Typeclassopedia. If you want to be able to trace how your monad-using code is evaluated this is a necessity. Like it or not. Also, attacking monads from both the concrete and the abstract at the same time seems to be a good approach, with satori being achieved once the understandings meet. A dynamic-programming approach?

You may possibly be disagreeing with the order in which he lists these components of learning in his 'Eightfold Path', but if the analogy to the Buddhist teachings is followed further, then the steps need not be taken in sequence.

The slides certainly include many monad examples besides maybe at any rate.

I think the slides are worth another look :)

kzrdude3• 13 years ago

Your pipeline example looks more fit for simple function composition.

  f = filter (\x color x == BlueColor) . select (\x color x == RedColor)

jes519910• 13 years ago

That's true for this example, but when you do tree walking stuff in jQuery (like elements.children().children() ) then you have to think of it as a concatting map instead as just a regular map or filter

lmm• 13 years ago

Agree 100% on just showing the real code. Don't tell me what a monad is, tell me a problem I can solve with it. (I've made my own attempt at http://m50d.github.io/2013/01/16/generic-contexts.html )

marshray5• 13 years ago

I've read lots of monad tutorials. I get it, they're a way of encapsulating side-effects in a pure lazy language.

But Haskell doesn't sink in unless I use on a regular basis. The time that I've felt like I was able to see a light at the end of the tunnel (i.e., that I might be able to be useful enough in Haskell that I could keep using it regularly) was when I simply memorized the expansions for the do, <-, return sugars.

chowells3• 13 years ago

You've just proved that the monad tutorials you've read are useless. Monads are emphatically not "a way of encapsulating side-effects in a pure lazy language". Haskell's IO type is a way of encapsulating side effects in a pure lazy language. Haskell's IO type happens to form a monad. The fact that it forms a monad is completely irrelevant to what it actually does.

Forming a monad is a very abstract consideration. It has to do with the data type supporting a couple operations with specific properties. It doesn't say a thing about what those operations mean, so long as the required properties hold. It's up to specific monads to insert semantics into those operations.

And so yes, the IO type specifies that its monad operations mean "creating a trivial IO action that gives a specific value when executed" and "feed the result of executing an IO action into a function that returns another action." And that turns out to be a sufficient framework for composing IO actions together, once something else is providing them.

But IO isn't the only monad. There are hundreds of others already defined, and an unlimited number that can be created. What matters is that they can implement a couple functions with the required properties.

So I've said monads are abstract. What's the point then? Well, put simply, a language with the kinds of primitives Haskell has can actually put the abstraction into its libraries. This allows writing code that works at the level of the abstraction, rather than any specific implementation. The monad abstraction turns out to be rich enough to implement all kinds of conditionals, loops and recursion structures, function application patterns, etc.

In fact, work with parser combinator libraries has shown that the monad abstraction is the simplest one that allows you to express any context-sensitive grammar. If you've ever studied automata theory, bells should be ringing about now. The monad abstraction is sufficiently rich to express Turing-complete operations over the kinds of types it applies to.

And that's the real point. The monad interface allows you to specify those kinds of operations generically. Once they've been written, you can apply them to any type that provides the interface (correctly).

The fact that there's an IO type that happens to provide the interface is an accident that's only relevant historically. The benefit is much larger than that.

This kind of comes down to Rich Hickey's "simple vs easy" point. Monads are incredibly simple, but they're not easy for people who aren't used to looking for deep abstractions. One of the insights made in Haskell library design is that category theory contains several ideas that are incredibly simple and powerful as abstractions for software creation. Monad is hardly the only one - it's just the only one getting press.

gavinpc• 13 years ago

Notwithstanding the critics, I've read many explanations of Monads, and I found this one helpful, especially coming off of Eric Lippert's:

http://stackoverflow.com/a/2704795/4525

I get it now, so thanks!

papsosouid2• 13 years ago

>I disagree completely with his analysis on monads

You say that, but your post doesn't actually show disagreement. He said to avoid analogies, not avoid real code. His list of steps in fact contains "use monads in real code".

rtkwe• 13 years ago

Nothing like getting a pile of slides without any presenter notes or anything else helping to interpret the slides.

mwerty• 13 years ago

I first learnt Haskell ten years ago for a class. Mostly toy problems. Looking to get back into it. What books are good to learn to build actual apps - especially user input, UI, etc.?

cies3• 13 years ago

realworldhaskell is good for general purpose.

i think the yesod o'reilly book (free on yesodweb.com) is a very good one if you dont mind to make web apps.

simpsond• 13 years ago

This post somehow triggered me to grab "Learn You a Haskell for Great Good" this morning and I have been gorging on it since then. I've had quite a few "holy shit" moments.

yayitswei• 13 years ago

I saw a blank page and immediately thought "how poetic".

Uchikoma• 13 years ago

"Haskell Propaganda: OOP programming couples code and data together in unnatural ways. Typeclasses are a better way of structuring logic."

should be

"Inheritance couples code and data together in unnatural ways. Typeclasses are a better way of structuring logic."

papsosouid2• 13 years ago

How so? An OOP language without inheritance would still be coupling code and data together "in unnatural ways". It is the object that is doing the coupling, not inheritance.

What I Wish I Knew When Learning Haskell

Related Stories