Ch5 - Convert unnecessary ADTs to type synonyms and add anchors (#254)

* Ch5 - remove getX getY

* Ch5 - Further simplify centerShape

* Ch5 - Use type synonym instead of ADT for Point

* Ch5 - improve Newtype section

* Ch6 - convert Show Point exercise from data to newtype

* Ch5 - anchors and chapter example tests

* Ch5 - Relocate and edit Record Puns section

* Ch5 - Do not use ADT for Bounds

* Ch5 - CI fix, add chapter examples

Author: milesfrain

exercises/chapter5/src/ChapterExamples.purs

@@ -0,0 +1,129 @@
+module ChapterExamples where
+
+import Prelude hiding (gcd)
+-- ANCHOR: lzsImport
+import Data.Array (tail)
+import Data.Foldable (sum)
+import Data.Maybe (fromMaybe)
+-- ANCHOR_END: lzsImport
+-- ANCHOR: unsafePartialImport
+import Partial.Unsafe (unsafePartial)
+-- ANCHOR_END: unsafePartialImport
+
+-- ANCHOR: gcd
+gcd :: Int -> Int -> Int
+gcd n 0 = n
+gcd 0 m = m
+gcd n m = if n > m
+            then gcd (n - m) m
+            else gcd n (m - n)
+-- ANCHOR_END: gcd
+
+-- ANCHOR: fromString
+fromString :: String -> Boolean
+fromString "true" = true
+fromString _      = false
+-- ANCHOR_END: fromString
+
+-- ANCHOR: toString
+toString :: Boolean -> String
+toString true  = "true"
+toString false = "false"
+-- ANCHOR_END: toString
+
+-- ANCHOR: gcdV2
+gcdV2 :: Int -> Int -> Int
+gcdV2 n 0 = n
+gcdV2 0 n = n
+gcdV2 n m | n > m     = gcdV2 (n - m) m
+          | otherwise = gcdV2 n (m - n)
+-- ANCHOR_END: gcdV2
+
+-- ANCHOR: isEmpty
+isEmpty :: forall a. Array a -> Boolean
+isEmpty [] = true
+isEmpty _ = false
+-- ANCHOR_END: isEmpty
+
+-- ANCHOR: takeFive
+takeFive :: Array Int -> Int
+takeFive [0, 1, a, b, _] = a * b
+takeFive _ = 0
+-- ANCHOR_END: takeFive
+
+-- ANCHOR: showPerson
+showPerson :: { first :: String, last :: String } -> String
+showPerson { first: x, last: y } = y <> ", " <> x
+-- ANCHOR_END: showPerson
+
+-- ANCHOR: showPersonV2
+showPersonV2 :: { first :: String, last :: String } -> String
+showPersonV2 { first, last } = last <> ", " <> first
+-- ANCHOR_END: showPersonV2
+
+-- ANCHOR: unknownPerson
+unknownPerson :: { first :: String, last :: String }
+unknownPerson = { first, last }
+  where
+    first = "Jane"
+    last  = "Doe"
+-- ANCHOR_END: unknownPerson
+
+-- ANCHOR: livesInLA
+type Address = { street :: String, city :: String }
+
+type Person = { name :: String, address :: Address }
+
+livesInLA :: Person -> Boolean
+livesInLA { address: { city: "Los Angeles" } } = true
+livesInLA _ = false
+-- ANCHOR_END: livesInLA
+
+-- ANCHOR: sortPair
+sortPair :: Array Int -> Array Int
+sortPair arr@[x, y]
+  | x <= y = arr
+  | otherwise = [y, x]
+sortPair arr = arr
+-- ANCHOR_END: sortPair
+
+-- ANCHOR: lzs
+lzs :: Array Int -> Array Int
+lzs [] = []
+lzs xs = case sum xs of
+           0 -> xs
+           _ -> lzs (fromMaybe [] $ tail xs)
+-- ANCHOR_END: lzs
+
+-- ANCHOR: partialFunction
+partialFunction :: Boolean -> Boolean
+partialFunction = unsafePartial \true -> true
+-- ANCHOR_END: partialFunction
+
+-- ANCHOR: electricalUnits
+newtype Volt = Volt Number
+newtype Ohm = Ohm Number
+newtype Amp = Amp Number
+-- ANCHOR_END: electricalUnits
+
+-- ANCHOR: calculateCurrent
+calculateCurrent :: Volt -> Ohm -> Amp
+calculateCurrent (Volt v) (Ohm r) = Amp (v / r)
+
+battery :: Volt
+battery = Volt 1.5
+
+lightbulb :: Ohm
+lightbulb = Ohm 500.0
+
+current :: Amp
+current = calculateCurrent battery lightbulb
+-- ANCHOR_END: calculateCurrent
+
+-- These are to enable testing. Will be explained in Ch6.
+derive newtype instance eqAmp :: Eq Amp
+derive newtype instance showAmp :: Show Amp
+
+-- ANCHOR: Watt
+newtype Watt = MakeWatt Number
+-- ANCHOR_END: Watt

exercises/chapter5/src/Data/Picture.purs

@@ -1,32 +1,36 @@
+-- ANCHOR: module_picture
 module Data.Picture where
 
 import Prelude
-
 import Data.Foldable (foldl)
+-- ANCHOR_END: module_picture
+-- ANCHOR: picture_import_as
 import Global as Global
 import Math as Math
+-- ANCHOR_END: picture_import_as
 
-data Point = Point
+-- ANCHOR: Point
+type Point =
   { x :: Number
   , y :: Number
   }
+-- ANCHOR_END: Point
 
-getX :: Point -> Number
-getX (Point p) = p.x
-
-getY :: Point -> Number
-getY (Point p) = p.y
-
+-- ANCHOR: showPoint
 showPoint :: Point -> String
-showPoint (Point { x, y }) =
+showPoint { x, y } =
   "(" <> show x <> ", " <> show y <> ")"
+-- ANCHOR_END: showPoint
 
+-- ANCHOR: Shape
 data Shape
   = Circle Point Number
   | Rectangle Point Number Number
   | Line Point Point
   | Text Point String
+-- ANCHOR_END: Shape
 
+-- ANCHOR: showShape
 showShape :: Shape -> String
 showShape (Circle c r) =
   "Circle [center: " <> showPoint c <> ", radius: " <> show r <> "]"
@@ -36,115 +40,132 @@ showShape (Line start end) =
   "Line [start: " <> showPoint start <> ", end: " <> showPoint end <> "]"
 showShape (Text loc text) =
   "Text [location: " <> showPoint loc <> ", text: " <> show text <> "]"
+-- ANCHOR_END: showShape
+
+-- ANCHOR: exampleLine
+exampleLine :: Shape
+exampleLine = Line p1 p2
+  where
+    p1 :: Point
+    p1 = { x: 0.0, y: 0.0 }
+
+    p2 :: Point
+    p2 = { x: 100.0, y: 50.0 }
+-- ANCHOR_END: exampleLine
 
+-- ANCHOR: origin
 origin :: Point
-origin = Point { x: 0.0, y: 0.0 }
+origin = { x, y }
+  where
+    x = 0.0
+    y = 0.0
+-- ANCHOR_END: origin
+-- Would generally write it like this instead:
+-- origin = { x: 0.0, y: 0.0 }
 
 getCenter :: Shape -> Point
 getCenter (Circle c r) = c
 getCenter (Rectangle c w h) = c
-getCenter (Line (Point s) (Point e)) = Point { x: (s.x + e.x) / 2.0, y: (s.y + e.y) / 2.0 }
+getCenter (Line s e) = (s + e) * {x: 0.5, y: 0.5}
 getCenter (Text loc text) = loc
 
+-- ANCHOR: Picture
 type Picture = Array Shape
+-- ANCHOR_END: Picture
 
+-- ANCHOR: showPicture
 showPicture :: Picture -> Array String
 showPicture = map showShape
+-- ANCHOR_END: showPicture
 
-data Bounds = Bounds
+-- ANCHOR: Bounds
+type Bounds =
   { top    :: Number
   , left   :: Number
   , bottom :: Number
   , right  :: Number
   }
+-- ANCHOR_END: Bounds
 
 showBounds :: Bounds -> String
-showBounds (Bounds b) =
+showBounds b =
   "Bounds [top: " <> show b.top <>
   ", left: "      <> show b.left <>
   ", bottom: "    <> show b.bottom <>
   ", right: "     <> show b.right <>
   "]"
 
 shapeBounds :: Shape -> Bounds
-shapeBounds (Circle (Point { x, y }) r) = Bounds
+shapeBounds (Circle { x, y } r) =
   { top:    y - r
   , left:   x - r
   , bottom: y + r
   , right:  x + r
   }
-shapeBounds (Rectangle (Point { x, y }) w h) = Bounds
+shapeBounds (Rectangle { x, y } w h) =
   { top:    y - h / 2.0
   , left:   x - w / 2.0
   , bottom: y + h / 2.0
   , right:  x + w / 2.0
   }
-shapeBounds (Line (Point p1) (Point p2)) = Bounds
+shapeBounds (Line p1 p2) =
   { top:    Math.min p1.y p2.y
   , left:   Math.min p1.x p2.x
   , bottom: Math.max p1.y p2.y
   , right:  Math.max p1.x p2.x
   }
-shapeBounds (Text (Point { x, y }) _) = Bounds
+shapeBounds (Text { x, y } _) =
   { top:    y
   , left:   x
   , bottom: y
   , right:  x
   }
 
 union :: Bounds -> Bounds -> Bounds
-union (Bounds b1) (Bounds b2) = Bounds
+union b1 b2 =
   { top:    Math.min b1.top    b2.top
   , left:   Math.min b1.left   b2.left
   , bottom: Math.max b1.bottom b2.bottom
   , right:  Math.max b1.right  b2.right
   }
 
 intersect :: Bounds -> Bounds -> Bounds
-intersect (Bounds b1) (Bounds b2) = Bounds
+intersect b1 b2 =
   { top:    Math.max b1.top    b2.top
   , left:   Math.max b1.left   b2.left
   , bottom: Math.min b1.bottom b2.bottom
   , right:  Math.min b1.right  b2.right
   }
 
 emptyBounds :: Bounds
-emptyBounds = Bounds
+emptyBounds =
   { top:     Global.infinity
   , left:    Global.infinity
   , bottom: -Global.infinity
   , right:  -Global.infinity
   }
 
 infiniteBounds :: Bounds
-infiniteBounds = Bounds
+infiniteBounds =
   { top:    -Global.infinity
   , left:   -Global.infinity
   , bottom:  Global.infinity
   , right:   Global.infinity
   }
 
+-- ANCHOR: bounds
 bounds :: Picture -> Bounds
 bounds = foldl combine emptyBounds
   where
   combine :: Bounds -> Shape -> Bounds
   combine b shape = union (shapeBounds shape) b
+-- ANCHOR_END: bounds
 
 {-
 These `instance`s are to enable testing.
 Feel free to ignore these.
 They'll make more sense in the next chapter.
 -}
-derive instance boundsEq :: Eq Bounds
-
-instance boundsShow :: Show Bounds where
-  show b = showBounds b
-
-derive instance pointEq :: Eq Point
-
-instance pointShow :: Show Point where
-  show p = showPoint p
-
 derive instance shapeEq :: Eq Shape
 
 instance shapeShow :: Show Shape where