learn4haskell

learn4haskell copied to clipboard

Just a collection of some ideas to improve the course and make some tasks better. A few things I have on my mind and discussed with @vrom911:

• [ ] Chapter 1: A simpler task before lastDigit that doesn't require thinking about corner cases.
• [ ] Chapter 2: Maybe eta-reduction task where you shouldn't eta-reduce?
• [ ] Chapter 3: A task on typeclasses to write the type of a function like foo x y = show (x + y).
• [x] Chapter 3: Make sure that the first fight is only one round, no recursion.
• [ ] Chapter 3: Clarify, that in Append people don't need to create a separate List newtype for lists.
• [ ] Chapter 4: The advanced task can make use of Monads to practice this topic more.

Task 4 "next" is too trivial and I think a very basic recursion example might be a better fit. I would remove Task 4, renumber Tasks 5-7 as 4-6 and insert a problem like this for a new task 7:

Enter an integer such that if the number is > 0 it will call the function recursively as n - 1 or n < 0 call recursively as n + 1 until n reaches 0. A sample solution might look like this:

countToZero :: (Num a, Num p, Ord a) => a -> p countToZero n | n == 0 = 0 | n < 0 = countToZero (n + 1) | n > 0 = countToZero (n - 1)

(Sorry for not so great formatting)

If I was writing this in JavaScript, I would actually want to console.log(n) as we count towards 0, not actually sure how to do that in Haskell yet! Only completed Chapter 1, but I am very much enjoying my first toe dip into Haskell. Else, all answers just give you zero, instead of something neat like this (if you did console.log(n) at each iteration):

countToZero 3 3 2 1 0 countToZero (-4) -4 -3 -2 -1 0

In any case, I think putting in a very basic recursion problem would help make the "final boss" easier to think through (although I don't think task 10 is exceptionally difficult as is either).

This probably falls out of the scope, but it would be great if there was Chapter 5 on reading & writing files, IO and do stuff. I find this the most confusing and discouraging part of Haskell.