Hi L-V,

I'm a C programmer, and I've gone through the article a couple times without enlightenment. This isn't necessarily the fault of the article, but thought I'd offer the places I couldn't follow. Perhaps they will be useful for understanding a beginners viewpoint.

  *int square(int n)    │    square :: Int -> Int*

Would be great if you offered an example where the argument and return type differed. As is, I don't know which order the Haskell declaration uses.

  Now it is possible to write the Haskell program that will
  naturally read from left to write

If this is essential at this point, it should be fleshed out more. Otherwise it feels like a distracting aside and out of place in a short introduction.

  -- before                        │    -- after
  compute n = baz (bar (foo n))    │    wiz     n = bar (foo n)
                                   │    compute n = baz (wiz n)

This seems perfectly clear, which makes me suspect the other parts are intended to be simple as well.

  (.) :: (b -> c) -> (a -> b) -> (a -> c)

Not clear why the left side is (.). Is this because it's non-alpha? Because it's infix? Something else? Order to read right hand side still unclear. Also don't know if reuse of a, b, and c as variables is significant.

  g . f = λx -> g (f x)

Can't quite follow, but this might be because I'm not sure if the λ is syntactically important, or just a naming convention.

  be expressed literally (see 1 vs λx -> g (f x));

I can't figure out what this means, possibly because I'm not sure what 'literally' means in this context. Also wasn't clear at first that "1" was meant as a number (or is that an 'L'), not a footnote or reference.

                       -- A List is either
  data List a = Empty  -- an empty node,  
  | Cons a (List a)    -- or a cons cell

Would help to define a "cons cell". Is Cons a data type or a function here? Is there a standard for capitalization? Not clear to me how the 'a' on the left side relates to the two on the right. Is 'data' a keyword, a type, or something else?

  inc-all l = map (λe -> e + 1) l

Throughout this whole section, I had no idea which characters were one's and which were L's. I ended up cutting and pasting into emacs and capitalizing. Perhaps something other than 'l' for the placeholder variable? Or it is more than a placeholder? The concept seemed straightforward, but the example was very hard to figure out.

  It is not obvious from the syntax, but Haskell functions      
  only have one argument.
  

Would help to mention this before the (.) example.

  Multiple arguments are emulated by returning functions.

So I guess this means the argument is on the left of the first '->' and the return type is to the right? And how should '->' be pronounced when spoken?

  inc-all (Cons e l) = Cons (foo e + 1) (inc-all l)

I'm guessing 'e' is 'element', and lower-case 'L' is list. Why/when did we switch from 'a' in the definition of List? And where did 'foo' come from? Is this a builtin function? A user defined function?

  map (a -> b) -> List a -> list b

Is the lower case for the last 'list' important? For that matter, is case important at all in Haskell? Also, are the types on the left for 'a' and 'b' defined by the given types on the right? Also haven't figured out why this declaration(?) has no '::' as the others do.

  dbl-all (Cons e l) = Cons (foo e * e) (inc-all l)

Is that supposed be 'dbl-all' at the end? And should that be "2 * e" instead of "e * e"? I'm hoping these are typos, otherwise I'm understanding even less than I thought.

  Note that the first argument is a function, hence the (a -> b) between parentheses.

Great! Confirmation on how to read the function declarations. Now back to reread the first half of the article again. Hopefully this means the return type is after the last '->'?

  Very simple, but without the fundamentals I just gave, 
  one hardly stands a chance at deciphering it. 

Unfortunately, I still don't feel confident in my ability to decipher now that I have have the been given those fundamentals. I think a gloss of what 'λe' actually means would help. As a type, is it parallel to "void * (* e)( void * )" in C?

Despite this long list, I appreciate that you wrote the article. Much better to have something possibly flawed than nothing at all. Maybe one day I'll actually understand it!