The New Haskell Homepage

Thank you, this is the best present ever :)

Is there a practical reason why there's so much empty space with this new design, and why so little valuable content and functionality is visible by default?

Viewing the existing site in a desktop browser, I get to see the description of Haskell, and a bunch of useful links about learning it, downloading an implementation, using it, and participating in the community. Recent news items and upcoming events are also visible, as is the search field.

This new design lacks pretty much all of that. Instead of useful content, links and functionality, all I'm seeing are large areas of purple and white, and an extremely blurry photo, along with content of very limited value.

I just can't see this new design being beneficial in any way. It makes it much harder to get useful information about Haskell, which seems very contradictory to what a website like this should be doing.

Hi, I think the visual refresh is a great idea.

Would you need some help in curating a better set of videos? I think that having some topics this advanced on the home page might scare of users, especially given their visual priority on the page.

Also, what's the plan on the view examples links on the page? Currently these don't link anywhere. Are you looking for existing articles that exist online to link to, or are you looking to have some content written that can be hosted on haskell.org.

What I personally would like to see:

    www.haskell.org: fun, introductory, digestible
    lang.haskell.org: the current haskell.org homepage, good bookmark for those who want the haskell portal

Can you please fix this markup? There should be a href on the <a> tag.

<p><a>View examples</a></p>

I love the tutorial! I couldn't help writing down some notes while going through it, here they are if you're interested in reading:

- Really would love to return to previous steps to review things (for example, reviewing what the difference is between a list and a tuple)

- "You just passed the (+1) function to the map function." But didn't I also pass [1..5] to it too? It's unclear to me whether map is a function which takes two arguments ... or if the first part "map (+1)" evaluates to a function which acts on [1..5]

- Is a (+1) a tuple with one item (the function "+1") or is it just similar syntax?

- Really like the exercises and would love to have more challenges interspersing the intake of new content. It honestly feels like the best way to learn.

I'm going to sleep for the night, otherwise I'd keep going. I'll return to it later. Looks promising!

P.S. Mini-bug report: Somehow this happened and it really confused me https://i.cloudup.com/0wRJS7FZls.png - looks like my 'try it again anyways' strategy saved me here. (there were no js console errors).

I'm a bit late, but perhaps you'll see this. Can you catch Ctrl+W in the REPL and use it to delete the prior word, instead of closing the tab? Kind of jarring to get into the groove of using a REPL and then accidentally close the tab.

I suggest you enable the `+m` flag for multiline input

This way, you don't have to use the weird curly braces trick (which I always forget), at the cost of having to type one more enter when entering a oneliner

FYI, this is my ghci.conf: https://github.com/berdario/dotfiles/blob/master/ghci.conf (I don't suggest a new user to use ClassyPrelude)

That said, I'm not sure what learning material to suggest to you, but if google and stackoverflow.com fails you, try freenode#haskell

personally, I got a lot more interested in Haskell after starting with Clojure (it helped me to appreciate more things like immutable data structures)

You could try IHaskell[0] for playing around with Haskell. It is like GHCi, but provides a notebook interface where you can enter multiline expressions and do declarations, so it is a lot closer to real Haskell. (It can be a bit of a paint o install though.)

Disclaimer: IHaskell author here :)

[0] https://github.com/gibiansky/IHaskell

It sounds like you're looking for Learn You A Haskell. Great book, free too read online, tells you how to start with Haskell step by step. http://learnyouahaskell.com/chapters

I too dislike tutorials focused around the REPL, because it's rarely how you write code in practice. The REPL is more of a debugging tool for quickly testing and manipulating code you've already written.

I'd jump directly into creating code files/modules - begin by creating simple programs using `main` as you would in other languages. Create a file with ".hs" extension, (Haskell filenames start with capital letters by convention, since they share the name of the module)

    main :: IO ()
    main = putStrLn "Hello World!"

Make sure the GHC bianries are in your PATH, and use the program "runhaskell File.hs" to quickly compile and execute them. Also, from ghci you can use the command (:load File.hs), if you want to debug stuff.

The preferred tool for writing Haskell though is emacs. If you're not familiar with emacs, its also a great opportunity to learn. Grab emacs 24, and open the file ~/.emacs, paste in this snippet:

    (require 'package)
    (add-to-list 'package-archives
             '("marmalade" . "http://marmalade-repo.org/packages/"))
    (package-initialize)

Then hit M-x (M for Meta, which is typically Alt), and type eval-buffer into the minibuffer at the bottom. If no errors, hit M-x and type into the mini-buffer:

    package-install haskell-mode

You can add the following to the .emacs file and use `eval-buffer` again. Also save with C-x C-s.

    (add-hook 'haskell-mode-hook 'turn-on-haskell-indentation)
    (add-hook 'haskell-mode-hook 'turn-on-haskell-doc-mode)

Next step is to just open an empty haskell file. Create a new directory for your project with `M-x make-directory`, and create a new haskell file using C-x C-f. Add some code, and hit C-c C-l (load in ghci), and emacs will pop open a new window, launch ghci and load your code into it.

You can switch over to the ghci window with C-x o (cycle windows), and type some code into it for testing. (Note it can be quite buggy if the cursor is not in the right place - there needs to be a space after the prompt > ¦). Useful keyboard shortcuts to remember here are M-p (previous) and M-n to cycle through previously used commands. (You can rebind any keys to how you wish.)

You can also add typicall IDE features like "run without debugging" and such with simple snippets of elisp. Say if we want to bind F6 to this command, we can add this hack to .emacs, save and eval the expression.

    (global-set-key [f6] 
        (lambda () 
            (interactive) 
            (async-shell-command (concat "runhaskell " buffer-file-name))))

Now with an active haskell file, F6 will launch like an application, bypassing GHCI - and emacs will typically open a new window (or replace an existing one) with the stdout/stderror for the application.

That'll get you started anyway. From there, using LYAH is a good beginner resource, although it won't get you much further than past the syntax and semantics of the core language. It doesn't cover the plethora of language extensions, building projects, using cabal, haddock, quickcheck and more. I'm not aware of a single resource which covers these though - I just learned what was needed as and when by searching - the best information typically comes from one-off blogs focused on a specific problem.

This http://dev.stephendiehl.com/hask/ overview is a little bit more advanced. It gives a good overview over the tools, some of the ecosystem and important libraries.

I've been reading "Learn You a Haskell for Great Good" and it has been going much more smoothly than it has apparently been going for you. It addresses pretty much all of your complaints.

http://learnyouahaskell.com/

> Please, get rid off the primes example, as it is horrible inefficient (in the sense of, "Ok, let's find the first n primes by a simple well-known algorithm, like the Sieve of Eratosthenes") and a simple (non-pure) array-based approach will kick its ass.

The primes example may be a bit awkward for people with no background in math but it's also an excellent example to demonstrate lazy evaluation in Haskell.

The interesting bit is that primes is an infinite list, containing all prime numbers. Don't try to print the whole list or count the sum unless you have a computer with infinite memory :)

If you ever wanted to know what a typical Haskell programmer sounds like, ^^this is it to a T.

Well it's the haskell.org landing page, of course they're showing off the type of code that Haskell is good at. In your link, the purely functional version (15 lines around a priority queue) is more complicated than a naive version with a mutable array, so why would they advertise it?

Agreed. That punctuation almost disappears depending on the angle of my laptop screen.

Also maybe pick a simpler example and not play into the stereotype that Haskell is for people who think they are smarter than everyone else.

I wrote a page that tries to explain the syntax in a way that's appropriate for programmers (who don't need to be shown how the REPL can be used as a calculator and things like that): http://dv.devio.us/a-quick-look-at-haskell.html

    Num a => a

is actually (Num a) => (a)

that is, Num a means roughly something like

    template<class a>
    class INum{
    }

`a` is an instance of `Num`

if you want to write a times2 function(f(x) = x*2), its type would be (with redundant parenthesis added)

     (Num a) => (a -> a)

so, a->a means it's a function that takes an `a` and returns an `a`... and `a` can be any thing that implements Num

The idea with haskell is that you heavily rely on polymorphism on the return types, this might make using code a little more awkward, since you have to explicitly say the type that you want to constrain to, but it makes writing generic libraries/APIs a lot easier, you might find this question interesting:

http://programmers.stackexchange.com/questions/105662/is-ret...

     `[2..]`

is the same thing as

     itertools.count(2)

in Python, an infinite sequence of number, starting from 2

    sieve something where sieve (p:xs) = yadayada

is usually written on multiple lines

    sieve something
      where
        sieve (p:xs) = yadayada

if you know that you can define a function with

    f x = something_with_x

it's somewhat obvious that you're defining a function called sieve that takes a (p:xs)

so, you're just defining a function and using it (with the [2..]) argument on the same line

   (p:xs)

is destructuring, it basically take a list (`(:)` is used to `cons`truct lists) and assign the first element of it to `p`, and the rest to `xs` (xs is a commonly used name for this in Haskell)

so, it's like calling

    sieve(list);

but you can define its signature as

    something sieve(T head, list<T> rest);

(`something` will turn out to be `list<T>`)

    /=

is indeed the same as !=, so (x `mod` p /= 0) is just (x is not a multiple of p)

    [x | x <- xs, x `mod` p /= 0]

is a list comprehension, and is taking all the elements from xs that aren't multiples of p

p, as suggested by the letter, is a prime... so you're recursively filtering the elements who are not multiples of p, leaving only the ones who are multiple only of 1 and p themselves (that is, primes)

finally, you're concatenating the prime you're currently acting on (p) with the infinite lazy list of all subsequent primes

Hope this helps

I agree, especially about the ":: Num a => a" stuff in the tutorial. berdario's comment above is illuminating, but it was pretty confusing and distracting while doing the tutorial. Not to say it shouldn't be there (I'm guessing it's important) but it should be explained.

Some acknowledgement would go a long way-- in the first "slide" after you see that, a sentence about the output format seems appropriate.

Being a god in C++ won't give you anything regarding foreign paradigms. Are you familiar with other FP languages such as ML, Miranda or even Lisp ? More than syntax it's the semantics that differs a lot. Laziness, Immutability...

Ok I'll take a stab at a super high level crash course:

A note! Haskell has weird syntax. But it actually uses this syntax in cool ways, as opposed to some languages that have weird syntax in an effort to be different.

Let's consider the basic unit of Haskell programming -- the function!

Here is a function which returns its input:

    f x = x

Notice that there are no parens or types or anything. Since functions are used so heavily, polluting them with parens would make your code look uglier than lisp.

Now notice that I didn't include a type signature. In haskell, you can omit them if you want. The compiler will figure out the most general type. Think of this as C++11 `auto` keyword on steroids.

If I were to include the type signature, it would look like this:

    f :: a -> a
    f x = x

Let's break down those symbols.

`::` just means "is of the type". So `f :: ...` is "function f is of the type..."

`a` is a type variable. Think of this like C++ templates! In C++, an equivalent function is

   template <typename T>
   T f(T x) { return x; }

Where `T` is the same as our `a` in Haskell. In Haskell, it's common to use the first few letters of the alphabet for type variables.

The `->` syntax is a bit funny, but it makes sense when you learn about function currying, which I will not explain now because it can be intimidating to some. For now, just think of the type signature as

    arg1Type -> arg2Type -> ... -> argNType -> ResultType

So for our function `f` of type

    f :: a -> a

That means "The function f takes some argument of type `a`, and returns a value of the same type `a`"

Now let's consider a more complex function.

    f x = 2 * x

As you can see, this is a doubling function. It takes a value and doubles it. We can imagine that the value it takes can't be any arbitrary type, because not all types can be doubled! So it doesn't make much sense to pass in a string.

In Java style, we might say that the type must implement the interface `Multipliable` or something. It turns out, Haskell has a system that is very roughly similar to Java interfaces or in C++, a class with a bunch of virtual methods.

Haskell calls these Typeclasses. So there is a typeclass that specifies that types in the typeclass must implement some basic numeric methods, such as +, -, etc. This typeclass is called `Num`.

So we can imagine, our doubling function only takes types that implement `Num`. Our type signature reads:

    f :: Num a => a -> a
    f x = x * 2

So everything between the :: and the => is typeclass specifications. So in this one, I just specify that type `a` must implement `Num`. Let's say I also required `a` to have the equivalent of a Java `toString` method, I would say:

    f :: (Show a, Num a) => a -> a

So now `a` must have a `toString` style method and must have numeric methods.

Now we are ready to approach the `primes` bit.

The first foreign looking thing is [2..]. This is an infinite list from 2 to infinity. How can one have an infinite list? The answer is laziness.

Whenever I go and ask for the 10000th value, the list must extend itself to that value if it hasn't yet. So the list only grows for as much as you ask for, but in theory it will grow until you run out of memory.

The [m..n] syntax is just nice syntactic sugar because it's used so much. [1..10] == [1,2,3,4,5,6,7,8,9,10]

[1..] == [1,2,3,4,5,....infinity]

So this is what we know so far:

    primes = sieve [2..]

Which means "primes is equal to the function sieve, called on an infinite list from 2 to infinity"

Now you ask, well what the hell is the function `sieve`?

Haskell has a nice sugar for defining scoped functions within other functions with the `where` keyword.

Consider the doubling function. I could instead do:

    f x = x * (three - one)
      where
        three = 3
        one = 1

So it just let's you define values that get used in the function body in a convenient place. This is akin to math jargon where people say "blah blah x something blah where x is blah".

So `sieve` is a scoped function (cannot be accessed from outside of `primes` that takes a list as an argument and apparently produces the primes that are in that list. How does it do it?

We see some weird syntax in the definition of `sieve`:

    sieve (p:xs) = ...

What is this? It's pattern matching. Let me use fake C++ as an example. Consider the recursive factorial function:

    int fact(int n) {
        if(n == 0) return 1;
        return n * fact(n-1);
    }

Now imagine if C++ let you do this instead:

    int fact(0) { return 1; }
    int fact(int n) { return n * fact(n-1); }

That is, you make a special case function body when the argument is 0. At runtime, if the arg is 0, it uses the special case body, otherwise it falls through to the general body.

So in Haskell, we could implement factorial like

    fact :: Num a => a -> a
    fact 0 = 1
    fact n = n * fact (n-1)

Very clean and sexy! But now you say "Yeah, but I could just use an if statement or a switch..."

Now we go into the funny syntax and power of that funny syntax! Not only can pattern matching match on values, but it can decompose those values. What do I mean? Again, let me use some fake C++ as an example.

Consider the C++ function

    int f(pair<int, int> my_pair) {
        int x = my_pair.first;
        int y = my_pair.second;
        return x*y;
    }

Ignore that there is no real reason to pull the values out into `x` and `y`. In a more complex function, I'm sure you can understand why it would be tedious to type `my_pair.first` over and over again and we would want to pull it into `x` or something.

Now imagine if C++ let us do this:

    int f(pair<x, y>) {
        return x*y;
    }

That is, f takes a pair, and in the type declaration we decompose the pair into its first and second parts, assigning them to the variables `x` and `y`. In Haskell, this is trivial.

Consider a direct translation of the C++:

    f :: (Int, Int) -> Int
    f my_pair = fst my_pair * snd my_pair

Now the idiomatic Haskell, with pattern matching decomposition:

    f :: (Int, Int) -> Int
    f (x,y) = x*y

Slick, right?

So what is `sieve (p:xs)` decomposing?

In Haskell, the default [] list is a linked list (there are random access arrays in various libraries). That means we can stick a value onto the front of the list in O(1) time. The way we stick a value onto the front of the list is with the `:` operator.

So

    x = [1,2,3]
    y = 0:x

`y` is now [0,1,2,3]

Just like we can compose lists with the `:` operator, we can decompose them via pattern matching with it.

So consider the function (I'll omit the type signature for brevity)

    f (p:xs) = print (p, xs)

Let's say we give `f` the argument [1,2,3,4]. What call to `:` would we have to make to get this list?

    [1,2,3,4] == 1:[2,3,4]

So when we send [1,2,3,4] into `f`, it gets decomposed into ` 1:[2,3,4] ` where 1 gets put into `p` and [2,3,4] gets put into `xs`.

This is a very common idiom in Haskell. Let's say I wanted to make a function that added 1 to every value in a list. Ignoring that there are much cooler/efficient ways to do this in Haskell, let's make a specialized function for it.

    addOne (x:xs) = x+1 : addOne xs

So let's read through that. In our pattern matching decomposition, we pull off the first value of the list and store it in `x`, and we take the rest of the list and store it in `xs`.

Now in our function body, we recompose a list with different values. Those values are `x+1` for the first value, and `addOne xs` for the second value. So we add one to the first value, and stick it into the front of the rest of the list after the rest has had 1 added to its values. You might notice now, that there is no bottom-out case for this recursion. So let's add one.

    addOne [] = []
    addOne (x:xs) = x+1 : addOne xs

So we pattern match to catch the special case of the empty list, which returns the empty list, and then we decompose the general case as previously explained.

So `sieve` is pulling off the first value, storing it in `p`, and taking the rest of the list and storing it in `xs`.

It is returning...

    p : sieve [x | x <- xs, x `mod` p /= 0]

So, that is `p` stuck onto the front of...

    sieve [x | x <- xs, x `mod` p /= 0]

And we know that sieve returns all of the primes within its argument, so in English...

    p stuck onto the front of all the primes in [x | x <- xs, x `mod` p /= 0]

So now what the hell is [x | x <- xs, x `mod` p /= 0]? It is a list comprehension.

Hackernews said my comment was too long. Read the rest here: http://pastebin.com/UesYMjjJ

> I understand it's normal usage syntax very well.

You understand C++ syntax because you're familiar with it, not because it is "normal" in any way.

Yours isn't an uncommon reaction, don't sweat it.

I remember being thoroughly confused by what I was reading back when I started learning Clojure, after years in C# and ruby. At first I thought no normal human being could understand just what the heck was happening amongst all of those parentheses, but eventually it became second nature. Now I've probably written a good 50KLOC in the language and to me it feels semantically dense, but nonetheless very readable.

I then remember switching to Haskell and thinking the same thing: "What the heck is this alien-speak mumbo-jumbo, how can anybody understand this gibberish?! Phooey!". Except this time I could actually remember myself saying the same exact thing 2 years earlier about Clojure and knew that if I just persevered, it'd eventually feel perfectly natural. It's been a few months, and it feels more natural now, even though admittedly Haskell has a lot more language constructs than the very basic lisp, so it takes a bit longer to build up that visual pattern recognition.

Honestly, we call them computer language for a reason, to a certain extent, you're saying you are very good at English but you can't for the life of you understand Japanese, all those weird symbols! Takes a while to be familiarized with a language and specially when the paradigm is completely different, not sure if it's a good or a bad thing (this paradigm change), but you'll have to make an initial effort, that's for sure.

> I guess primes is a thing (function?) that takes 2 or more things?

Primes is an infinite list of integers containing all prime numbers. It's not a function, it's a value just like any other list of integers.

You obviously can't do something like that in C++ or most other languages. I think that's a pretty good example to demonstrate the difference between a pure and lazy language like Haskell and the more mainstream kind of languages.

If you're primarily a C++ programmer, Haskell should feel alien to you. It's a good thing. The differences in syntax are only skin deep, the differences in the semantics is what is interesting.

To complement some of the great answers here, I would like to point out that in Haskell, instead of objects carrying around a vtable pointer, the typeclass dictionaries get passed arount as extra implicit arguments to the functions.

This is important when you have binary operations like `+`. In haskell both operands must be the same type while with OO interfaces the operands can have different concrete implementations.

" λ 5 + 7 12 :: Num a => a What the christ? The 12 I get. Got it. The colons? Not sure. I think it's just a dumb separator. Num is type! What the hell is a => a? I have no idea."

:: means "the stuff after this is the type signature"

Normally, a type signature can be as simple as something like

'x' :: Char

which is the type signature of the character 'x'. Looking at the type signature of 12 shows two parts "Num a =>" and "a". This can be read as "it returns a generic type `a` that must be an instance of the type class Num", which sounds really complicated but isn't.

The "Num a =>" is a type class constraint on the returned type "a". Type classes are basically like interfaces, they set up constraints and methods that need to be implemented for that type, analogous to how in other languages a class can implement an interface. For example, the Eq type class mandates you define the (==) and (/=) methods for that type, analogous to how something like the interface Comparable in Java requires you to define the compareTo method.

Thus the concrete type "Integer" is an instance of type class "Eq" because it implements those (==) and (/=)

Num is an example of a type class, just like Eq. But Num requires you to define a few more methods

  class Num a where
  (+) :: a -> a -> a
  (*) :: a -> a -> a
  (-) :: a -> a -> a
  negate :: a -> a
  abs :: a -> a
  signum :: a -> a
  fromInteger :: Integer -> a

So all of the things you think of as "numbers" are all types that implement "Num", e.g. an Integer, a Float, a Double.

So going back, "12 :: Num a => a" means 12 can be any type which implements Num, which is really just a fancy way of saying "this number can be cast into any numeric type". You can perform this casting manually!

  λ (5 + 7) :: Integer
 12:: Integer
  
  λ (5 + 7) :: Float
  12.0:: Float

Also typing in their code example (the one right at the top, pride of place) into their 'Try it' repl throws an error:

    primes = sieve [2..]
        where sieve (p:xs) = 
          p : sieve [x | x <- xs, x `mod` p /= 0]

    <hint>:1:8: parse error on input `='" error

Now I have almost no knowledge of Haskell, so I'm probably making some really basic mistake, but I figure most visitors will try that and then get put off

> The blurry photo of (I assume) the audience of a lecture just doesn't work - what's it supposed to do?

It has links to a bunch of lectures/videos right below it, so I'm guessing that's why it's there...

I got that too. I was surprised to realize that I felt ready to completely give up on the language after seeing only that message.

I agree, but I'd go even further: make the example in the corner actually tryable the "Try It" section.

For this example:

  primes = sieve [2..]
      where sieve (p:xs) = 
        p : sieve [x | x <- xs, x `mod` p /= 0]

I tried to type it into the shell:

  λ primes = sieve [2..]
  <hint>:1:8: parse error on input `='

It doesn't work. Okay, what if I copy and paste?

  λ primes = sieve [2..] where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]
  <hint>:1:8: parse error on input `='

Doesn't work.

Now, I know enough about Haskell to know what I can and can't type into ghci, but what about people who are encountering Haskell for the first time? They'll try to run the given example in the "Try It" section and will get nothing but errors. Just my two cents.

P.S. Is Haskell still avoiding success at all costs? (A philosophy I continue to be okay with, but it seems to getting futile :) )

There's a difference between crashing and returning null. If head returned null on an empty list, that null could be passed around to different places in the program before it crashed from a null pointer exception.

There can be unexpected crashes in Haskell, but not because of null.

There are a couple of Prelude functions that are broken, most notably `head` and `tail`. The problem is that they use non-exhaustive pattern matching in their definition:

    head :: [a] -> a
    head a:_ = a

    tail :: [a] -> [a]
    head _:as = as

Fortunately, use of these functions is unidiomatic, not just because they're one of the only ways that haskell programs can crash, but because they're less clear than the alternative, pattern matching. The haskell compiler will give you a warning by default if you write a function that performs a non-exhaustive match.

tl;dr: head and tail are mistakes, but they're never used.

This would be a massive improvement.

Yes, the new page is signed by Chris Done at the bottom. I'm glad the Haskellers listened to his advice and accepted the proposed design; now it's time to tweak it with some real use.

I noticed as well that there was "no context for the videos".

Yeah, perhaps replacing those videos with a gallery of places to start learning. Website previews, book covers, etc.

It fits the tradition established by the quicksort that isn't really a quicksort.

I had a similar experience with Cabal. On one computer I haven't been able to install Yesod whereas on another one, it finally worked after I had wiped my ~/.cabal. It gave me the impression that Cabal's dependency resolution mechanism is still a bit britle.

Also I found that installing stuff through Cabal was pretty slow. It's probably partly because Haskell libraries tend to be kept narrow in scope so it's necessary to install a lot of small packages to get a piece of functionality (take for instance the dependency list of Aeson, which seems to be the recommended choice for working with JSON : http://hackage.haskell.org/package/aeson ). Another reason is that Cabal compiles Haskell code into native code.

It doesn't seem to support function declaration.

It's a somewhat limited shell. You can't make local definitions. Normally you'd do that using `let` in GHCi, but this prompt only evaluates expressions.

A video like this could also be cool to have on the front page.

This gets brought up often, but side-by-side comparisons don't really work, because the languages are too different for them to be meaningful for anything but trivial expressions. To really understand Haskell, you need to somewhat unlearn Java - or at least, stop thinking in it (in terms of objects, state and method calling).

I think a good approach to thinking differently is to look how data structures are done - most programmers recognize arrays, lists, stacks and queues, but might be confused as to how you would implement such thing without side effects. A great resource to explain this is Okasaki's Purely Functional Data Structures[1], although it doesn't use Haskell at all, the ideas are relevant, and you can work through all of the examples implementing Haskell equivalents.

[1]:https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf

Neither on Firefox (default settings) on Ubuntu.

yep, you are not the only one that had that problem

λ foldr (:) [] [1,2,3]

:: Num a => [a]

λ foldr (:) [] [1,2,3]

[1,2,3] :: Num a => [a]

me too..

  λ let (_,(a:_)) = (10,"abc") in a
  can't find file: Imports.hs
  λ let (_,(a:_)) = (10,"abc") in a
  'a'
  :: Char

I recommend the IRC channel, the Haskell Cafe and Haskell Beginners mailing lists. People are helpful - talk to them.

I understand the Haskell wikibook is also great at the introductory level.

This will help: https://github.com/bitemyapp/learnhaskell

Learn You A Haskell is a good book (and it's free online).

Would strongly recommend the #haskell-beginners channel on Freenode, it's there specifically to support people just starting with the language.

If you're on OS X or Linux, you should not use the Haskell Platform. It's a whole lot of pain for literally no gain...

Looks like you're being downvoted, but I have to agree with you, especially given some of the examples right at the top.

  foldr (:) [] [1,2,3] 

There is absolutely nothing natural about that line of code unless you happen to already have some background. I executed that in the sandbox and got:

  [1,2,3]:: Num a => [a]

And I still don't know what was achieved.

Depends on the intended meaning -- if it is that Haskell is advanced among purely-functional programming languages, rather than both advanced and purely-functional among programming languages, then the former is far better.

I agree about the download page being too subtle: I _really_ love this new redesign - the old site was impossible to figure out what I was supposed to do or what was going on or what the hell "cabal" was. This new site is clean and clear: but still missing a nice big call to action (besides the live coding part).

Once you've looked at the live coding, the next thing is "community" which is great for docs, but not so great for "getting up and running" - which was also hard to figure out on the old site. I'd prefer to be lead from the live coding to clear instructions how to get Haskell running on my system.

But, again - I love this redesign... great work!

> Don't make me pick between concise and reliable.

You missed the tongue-in-cheek, there. "Concise and Reliable: Pick Two."

And those people are in a lecture hall. Under "Open-source community effort."

Perhaps, but it wouldn't hurt to pollute your mind with SICP first. At least watch the Abelson/Sussman videos (an accelerated version for HP employees); the audio sucks on a couple of them (I mean, in a couple of the lecture videos the audio sucks with much greater force than it sucks in the rest of them, but it's still not quite as bad as Feynman's Robb lectures), but it's a small time sink for a lot of enlightenment.

Scheme and Haskell are very different languages. Both are functional, but that's about where the similarities end. Scheme is impure, haskell is pure; scheme is strict, haskell lazy; scheme is dynamically typed, haskell static; all functions in scheme are variadic, all in Haskell are unary; etc. So it depends on what you're looking for, and what you're trying to use it to do. That said, here are some advantages of Haskell:

1) Speed. Haskell binaries are highly optimized and tend to be very fast.

2) Correctness. Haskell's type system is far more advanced than any other language with as much or more usage, and is very good at preventing runtime errors. (and can go a long way to preventing logic errors). Also, its purity prevents huge classes of bugs.

3) Interesting: Haskell introduces a lot of new concepts which can really open up your understanding of computer science. It's a lot of fun.

4) Forward-looking: many of the ideas introduced or popularized by Haskell, such as pattern-matching, type classes, no null pointers, etc, are manifesting themselves in the new languages these days (such as Rust and Swift). Haskell itself is also (slowly) making its way into industry. Learning Haskell, in some ways, exposes you to the "next generation" of languages and programming techniques. I'm not sure the same can be said of Scheme, which tends to be used pedagogically more than as a means to push the envelope.

Then again, I know Haskell a lot better than I know Scheme, so maybe I'm biased. But at least, it gives you something to think about.

haskell can be used for pretty much everything (even hard realtime with a code generating dsl called atom), so just think about what you enjoy/like and maybe ask before for pointers to libraries you might use with that task.

if there is anything you like but is algorithmically challenging, all the better. it's very nice to express math in haskell.

How would the REPL look like with progressive enhancement?

"Thanks submitting a Haskell line! You're being redirected to the output of the evaluation. If you're not being redirected automatically, please click _here_"