Ch7 derived solutions (#235)

* Ch7 point to generic derive guide and include manual solutions too

* Rely on derive content from previous chapter

Author: milesfrain

exercises/chapter7/test/no-peeking/Solutions.purs

@@ -75,14 +75,31 @@ data Tree a
   = Leaf
   | Branch (Tree a) a (Tree a)
 
--- These may alternatively be written by hand, rather than derived from generic.
+-- Solution using derived instances:
+
+derive instance eqTree :: Eq a => Eq (Tree a)
+
 derive instance genericTree :: Generic (Tree a) _
 
+instance showTree :: Show a => Show (Tree a) where
+  show t = genericShow t
+
+{-
+-- Solution using manually-written instances:
+
 instance eqTree :: Eq a => Eq (Tree a) where
-  eq t = genericEq t
+  eq Leaf Leaf = true
+  eq (Branch t1a va t2a) (Branch t1b vb t2b)
+      =  t1a == t1b
+      && va  == vb
+      && t2a == t2b
+  eq _ _ = false
 
 instance showTree :: Show a => Show (Tree a) where
-  show t = genericShow t
+  show Leaf = "Leaf"
+  show (Branch t1 v t2) =
+    "(Branch " <> show t1 <> " " <> show v <> " " <> show t2 <> ")"
+-}
 
 -- Exercise 2
 instance functorTree :: Functor Tree where

text/chapter7.md

@@ -645,6 +645,14 @@ Other traversable functors include `Array`, and `Tuple a` and `Either a` for any
      data Tree a = Leaf | Branch (Tree a) a (Tree a)
      ```
 
+     Recall from the previous chapter that you may either write these instances manually or let the compiler derive them for you.
+
+     There are many "correct" formatting options for `Show` output. The test for this exercise expects the following whitespace style. This happens to match the default formatting of generic show, so you only need to make note of this if you're planning on writing this instance manually.
+
+     ```
+     (Branch (Branch Leaf 8 Leaf) 42 Leaf)
+     ```
+
  1. (Medium) Write a `Traversable` instance for `Tree a`, which combines side-effects from left-to-right. _Hint_: There are some additional instance dependencies that need to be defined for `Traversable`.
 
  1. (Medium) Write a function `traversePreOrder :: forall a m b. Applicative m => (a -> m b) -> Tree a -> m (Tree b)` that performs a pre-order traversal of the tree. This means the order of effect execution is root-left-right, instead of left-root-right as was done for the previous in-order traverse exercise. _Hint_: No additional instances need to be defined, and you don't need to call any of the the functions defined earlier. Applicative do notation (`ado`) is the easiest way to write this function.