Learn Haskell in minutes

http://learnxinyminutes.com/docs/haskell/

by AaronO • 13 years ago

49 22 13 years ago

learnxinyminutes.com

octo_t• 13 years ago

Technically the quicksort at the end of the tutorial isn't idiomatic quicksort, the memory complexity is wrong.

quchen2• 13 years ago

Even for linked lists, which is how [] is defined in Haskell?

taeric• 13 years ago

I believe the idea is that if it is not "in place," it is not quick sort.

egonschiele3• 13 years ago

Correct. Sadly explaining monads and mutable data in Haskell would make this guide a lot longer. The example I gave is the traditional "look has elegant Haskell is!" example, not the "look how fast Haskell is!" example :)

DanWaterworth2• 13 years ago

You could use mergesort instead:

    merge :: Ord x => [x] -> [x] -> [x]
    merge [] y = y
    merge x [] = x
    merge (x:xs) (y:ys) =
      if x < y then
        x:(merge xs (y:ys))
      else
        y:(merge (x:xs) ys)

    odds :: [x] -> [x]
    odds [] = []
    odds (x:xs) = x:(evens xs)

    evens :: [x] -> [x]
    evens = odds . drop 1

    mergesort :: Ord x => [x] -> [x]
    mergesort [] = []
    mergesort [x] = [x]
    mergesort x = merge (mergesort (odds x)) (mergesort (evens x))

quchen2• 13 years ago

Apart from pattern matching (which isn't unique among functional languages), this contains zero things about Haskell that make it good (or even usable) - type classes, more complex data types, how reusable the code is etc.

I feel like the only thing these "learn X in Y minutes" pages are good for is for looking at other languages and judge the way their syntax looks like.

Furthermore, I don't think it is necessary to post a link here every time someone adds a new file to his website.

gtani• 13 years ago

here's some pretty good haskell cheats. [[well nigh impossible to cover all the language extensiosn in a short doc]]

http://www.cl.cam.ac.uk/~ns441/files/thips.pdf

http://blog.codeslower.com/static/CheatSheet.pdf

http://strictlypositive.org/slicing-jpgs/ (handdrawn!)

http://blog.ezyang.com/2011/11/how-to-read-haskell/

http://www.fing.edu.uy/inco/cursos/proggen/Transparencias/Po...

egonschiele3• 13 years ago

Author here. Yes! A lot of Haskell is missing from this guide. I couldn't find a good way to explain those concepts while still keeping the guide at 5ish minutes. I would love to see type classes in here though, so please make a pull request! Adam has been very fast about merging mine in so far.

DanWaterworth2• 13 years ago

Shameless plug: See also, "How do functional languages handle random numbers?" - http://programmers.stackexchange.com/questions/202908/how-do... .

colorido• 13 years ago

A small error, in section 8, input must be input1

Also in order to use ghci with this examples, multiples lines must be separated with semicolon.

lucian19002• 13 years ago

"Its"!

elisee• 13 years ago

Pointing out grammar mistakes doesn't add anything of value to the HN conversation. It's an open source project, so rather than post a comment here, I took a minute to fix the errors and submitted a pull request. Consider doing the same next time.

EDIT: Two minutes later and it's merged already :) https://github.com/adambard/learnxinyminutes-docs/pull/78

lucian19002• 13 years ago

I didn't read far enough to see the issue link.

ancarda2• 13 years ago

Unfortunately there doesn't seem to be any docs to learn Go. Can anyone point me in the direction of an equally good tutorial for Go?

thenonameguy• 13 years ago

https://gobyexample.com/

ancarda2• 13 years ago

Thank you for that!

agentultra• 13 years ago

The section on strings mentions an operator and type that isn't explained for another couple of sections:

   "Strings are lists" !! 0 -- 'S'

That could probably be omitted or the logical progression modified so that you learn about `!!` and lists first.

Of course, ignore my suggestion if the whole "learn x in y minutes" format assumes prior knowledge of programming language concepts.

paulkoer2• 13 years ago

I am afraid this is not a very good guide. I am by no means a Haskell expert, but even I can pick out a number of things which are not done very well and are not idiomatic Haskell. For example:

myMap func [x] = [func x]
myMap func (x:xs) = func x:(myMap func xs)

myMap does not deal with the empty list, will throw an exception if it is called with one, and there is no reason for it. (Just replace myMap func [x] = [func x] with myMap func [] = []).

Several functions that throw exceptions on empty lists (head, last) are introduced without any warning (such functions are considered bad style by many Haskellers).

-- Haskell has a very strong type system, and everything has a type signature.

I believe a 'type signature' is the annotation, and no, not everything in Haskell has a type signature. Everything has a type.

-- if statements

If is not a statement in Haskell, it is an expression. Same with case 'statements'.

There were quite a few more, see discussion on the Haskell reddit: http://www.reddit.com/r/programming/comments/1h917l/learn_x_...

Not all have been fixed. I love the idea of this, but I think these issues should be addressed before people actually use this to 'learn' Haskell.

Edit: corrections

egonschiele3• 13 years ago

Hey there! I wrote this Haskell guide.

1. myMap: fixed, good catch.

2. Using `head` and `last` being bad style: Where did you hear this?

3. The fixed the issues in the reddit thread yesterday. Here's the commit if you want to check it out: https://github.com/adambard/learnxinyminutes-docs/pull/62

Is there something specific that you think should be fixed?

paulkoer2• 13 years ago

Re 2: Well, sometimes you need them, but they do throw exceptions on empty lists, so if you don't know for sure that the list is non-empty it is definitely a bad idea to use them. I just thought a warning would be in order when presenting them. This is a point where Haskell's type safety (can't know at compile time if a list is empty or not) falls short and I think a lot of Haskellers try to avoid such functions for this reason. For example the Xmonad code uses zippers in a few places instead of lists which always have one element.

There's a few more points that I can't go into in detail due to lack of time (reason for use of recursion instead of loops, if / case statements, purity) and I do appreciate the effort and can imagine that it will prove useful but I felt obliged to point out these things. If I can see them it's not a good sign ;)

hamburglar• 13 years ago

Why do all of these "Learn X in Y minutes" tutorials need to be spammed to HN? Please stop.

Learn Haskell in minutes

Related Stories