Ch6 - Clarify Action type class exercises

[milesfrain]

I suspect these exercises could be clarified a bit to make them more beginner friendly (without giving away the solutions).
https://book.purescript.org/chapter6.html#exercises-3

[razcore-rad]

I'm around this area in Ch6 and these exercises aren't clear at all. First thing a beginner would run into is the confusion between Monoid and String. The exercise introduces the Multiply Int Monoid instance and then instructs us to search for String -> Int -> String with the observation that the function signature might be more generic.

The function we're looking for is power :: forall m. Monoid m => m -> Int -> m and I'm more than certain that beginners won't make the connection because the talk about arrays and strings being semigroups & monoids was way at the top and by the time you go through functional dependencies and type classes your brain will be barely making any connections.

I think there needs to be a refresher provided before the exercises.

The second problem is you'll get an error in the exercise if you don't implement the Action Multiply Int instance which is tested for but there's no corresponding exercise. This should be an exercise in itself, before moving to the string action instance.

[razcore-rad]

For the last difficult exercise about Action there's a lot of requirements. This is where derive newtype mentioned in #149 would come in handy.

My solution is:

class Monoid m <= Action m a where
  act :: m -> a -> a

newtype Multiply = Multiply Int

derive newtype instance showMultiply :: Show Multiply
derive newtype instance eqMultiply :: Eq Multiply

instance semigroupMultiply :: Semigroup Multiply where
  append (Multiply m1) (Multiply m2) = Multiply $ m1 * m2

instance monoidMultiply :: Monoid Multiply where
  mempty = Multiply 1

instance actionMultiply :: Action Multiply Int where
  act (Multiply m) n = m * n

instance repeatAction :: Action Multiply String where
  act (Multiply m) s = power s m

instance arrayAction :: Action m a => Action m (Array a) where
  act m as = act m <$> as

newtype Self m = Self m

derive newtype instance showSelf :: Show m => Show (Self m)
derive newtype instance eqSelf :: Eq m => Eq (Self m)
derive newtype instance semigroupSelf :: Semigroup m => Semigroup (Self m)
derive newtype instance monoidSelf :: Monoid m => Monoid (Self m)

instance selfMultiplyIntAction :: Action (Self Multiply) Int where
  act (Self (Multiply m)) n = m * n

instance selfAction :: Monoid m => Action m (Self m) where
  act m1 (Self m2) = Self $ m1 <> m2

Which cuts a bit the boilerplate.

[milesfrain]

1. What about giving away more information in the hint?

Note that String might appear as a more generic type (such as a Monoid).

I also want to include more examples in pursuit for power to make this easier to find, but then thinking it would be even better to cut down on PR overhead and pick a chuck of time to tackle adding examples for everything in prelude.

2. Yep. An exercise for Action Multiply Int should be added.

3. Showing readers the convenience of derive newtype is nice, especially since that's only necessary in the last Self exercise.

I'll create a PR for these changes. Found a few more things to fix while poking around in this chapter.