nomeata / haskell-for-readers Goto Github PK

Hi, this project looks really cool! Would it be possible for you to add a readme with set up instructions and example usage? Thanks.

First time ever I've done anything like this so don't know the protocol. Also non-native English speaker.

• "This document is work in progress" -> a (?) work in progress
• "will gain useful insight from tutorial" -> from this tutorial
• "The exercises are not sufficient in number and depths" -> depth
• "to provide the reader the experience needed" -> with the experience
• "are marked with ★" -> with a (?) ★
• "Functional program" -> programming
• "Both operator are left-associative" -> operators
• "which is again shorter than" -> smaller than
• "no parenthesis or commas needed" -> parentheses
• "and less noise code" -> noisy
• "If you leave out the parenthesis, you get a horrible error messages" -> If you leave out the parentheses, you can get horrible error messages ... but if you leave out a parenthesis, you can get a horrible error message ... or can get horrible error messages. [So this is about plurals, their spelling and the correct articles associated with them.]
• "the same as parenthesis around the rest of the line" -> parentheses
• "because the dollar operator it is not part of the built-in language" -> delete it
• "but can be define by anyone" -> defined
• "isHalfRound x = x div 10 == 0 || x div 10 == 5" -> div should be mod
  --> Other occurrences: "isEven x = x div 10 == 0 || x div 10 == 2 || x div 10 == 4 || x div 10 == 6 || x div 10 == 8" "x div 10 == y" "hasLastDigit x y = x div 10 == y" "x divides y = x div y == 0"
• Unicode Character 'FULL BLOCK' in "countDigits n = if n < 10 then 1 else █" "countDigits n = if n < 10 then 1 else (n div 10)█" "countDigits n = if n < 10 then 1 else countDigits (n div 10)█"
• "Use this function and countDigits to write a function isMultipleOf3 so that isMultipleOf3 x is true if repeatedly applying countDigits to x results in 3 or 9."
  "isMultipleOf3 x = fixEq sumDigits x == 3 || fixEq sumDigits x == 6 || fixEq sumDigits x == 9"
  Specification: use countDigits. Implementation uses sumDigits.
• "Instead of defining a countDigits as a function" -> delete first a
• "deep and beautiful explanation we write multiple arguments" -> why (?) we write
• "composition of a bunch of function" -> functions
• "points-free" -> point-free or pointfree?

Section 2 and on later. Unless I'm going about this all wrong ... I'm sure you will let me know in that case.

This isn't completely true. In particular, $ is hardcoded in GHC to support impredicativity in a way that user-defined functions can't. The best-known case of when that matters is when using it with runST. Specifically, this is valid:

runST $ do
  return 42

But this isn't:

runST `myDollar` do
  return 42

The text implies that the Semigroup class has an mempty function. It does not.

In Type Classes > Overloading, you have this type that needs to be corrected:

class Eq a where
    (==) :: a -> a -> a

About this sentence
we can say that function application behaves like an right-associative operator of highest precedence

Shouldn’t that be left-associative?

I think the phrase "With (>>=), you choose which action to do as the second argument based on the return value of the action of the first argument." is not as intended. Section 6.7

In Exercise 25, the reader is expected to implement
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c) (1)
which the same as the "official" delcaration
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> (m c) (2).

The presented solution is (a >=> b) x = a x >>= b. I feel like the solution rather "fits" to (2) and (>=>) a b = (\x -> a x >>= b) (or similar) would be an "appropriate" solution of (1). I understand that this is just a matter of style. I just felt it could be made a bit more intuitive - given the target audience.

I think the syntax for data declarations is one of the uglier parts of haskell, and one I see beginners struggle with (and something I remember finding confusing).

data Foo a b = Bar Int Char a | Foo 
     \_____/   \_/ \________/   \_/
       Type   Term    Type     Term (n.b. this `Foo` is in a totally 
                                different namespace from the type `Foo`)

The difficulties are:

• there's a lot of punning going on, with type- and term-level stuff mixed together
• confusing things further, type and data constructors often share the same name (and "constructor" is a kind of unsatisfying overloaded term)
• the = is fairly meaningless (note in type syntax the = actually means =, i.e. what we have is a simple type-level function; I think it might make sense to introduce type first since the syntax is much more sensible.
• the | are unrelated to guards but that might confuse people
• the way the syntax relates to patterns can be confusing, e.g. Foo a b = ... looks like a pattern but isn't, likewise (Bar Int Char) isn't a valid pattern

I think the most important thing is to make totally clear which parts of the declaration correspond to things that live in type signatures and which things only live in code (maybe by highlighting an example in two different colors). Then you could show a code snippet that uses all the pieces from the declaration with the same highlighting (the type in a type signature, data constructors in both patterns and in RHS).

I don't know how much of the other stuff is necessary to mention/gripe about, but I think it can sometimes be encouraging to learners to hear that something they find confusing or weird is actually confusing/weird/bad.

sorry I don't have a proper edit to suggest right now, but I might be able to open a PR later if you are interested