Add guessing-game exercise

Author: pwadsworth

config.json

@@ -68,6 +68,18 @@
         "concepts": [
           "booleans"
         ]
+      },
+      {
+        "slug": "guessing-game",
+        "name": "Guessing Game",
+        "uuid": "fb9868eb-ce4f-4e6b-aa0d-b47d3451070f",
+        "prerequisites": [
+          "numbers"
+        ],
+        "status": "beta",
+        "concepts": [
+          "pattern-matching-literals"
+        ]
       }
     ],
     "practice": [

exercises/concept/guessing-game/.docs/hints.md

@@ -0,0 +1,25 @@
+# Hints
+
+## General
+
+- Learn You A Haskell has a nice [introduction to pattern matching in Haskell][pattern-matching].
+
+## 1. Reply to a correct guess
+
+- You can use a constant pattern to match on a specific number.
+
+## 2. Reply to a close guess
+
+- You can use a constant pattern to match on a specific number.
+
+## 3. Reply to too low guesses
+
+- You can use a combination of a variable pattern and [guards][guards].
+
+## 4. Reply to too high guesses
+
+- You can use a combination of a variable pattern and [guards][guards].
+
+
+[pattern-matching]: https://learnyouahaskell.github.io/syntax-in-functions#pattern-matching
+[guards]: https://learnyouahaskell.github.io/syntax-in-functions#guards-guards

exercises/concept/guessing-game/.docs/instructions.md

@@ -0,0 +1,49 @@
+# Instructions
+
+In this exercise, you are playing a number guessing game with a friend.
+The rules are simple: you secretly choose a number between `1` and `100` and your friend tries to guess what number you've chosen.
+To help your friend, you respond differently depending on how close the guess was to the number you've chosen (`42`).
+These are the rules for the different possible inputs:
+
+- If the guess is `42`: "Correct"
+- If the guess is `41` or `43`: "So close"
+- If the guess is less than `41`: "Too low"
+- If the guess is greater than `43`: "Too high"
+
+You have four tasks to encode the replies to the guesses.
+
+## 1. Reply to a correct guess
+
+Implement the `reply` function to reply to a correct guess:
+
+```haskell
+reply 42
+-- -> "Correct"
+```
+
+## 2. Reply to a close guess
+
+Modify the `reply` function to reply to close guesses:
+
+```haskell
+reply 41
+-- -> "So close"
+```
+
+## 3. Reply to too low guesses
+
+Modify the `reply` function to reply to too low guesses:
+
+```haskell
+reply 25
+-- -> "Too low"
+```
+
+## 4. Reply to too high guesses
+
+Modify the `reply` function to reply to too high guesses:
+
+```haskell
+reply 88
+-- -> "Too high"
+```

exercises/concept/guessing-game/.docs/introduction.md

@@ -0,0 +1,57 @@
+# Introduction
+
+## Pattern Matching Literals
+
+While `if/else` expressions can be used to execute conditional logic, Haskell also has a more powerful way to execute conditional logic: [pattern matching][pattern-matching].
+With pattern matching, a value can be tested against one or more _patterns_.
+An example of such a pattern is the _constant pattern_, which matches a value against a constant (e.g. `1` or `"hello"`).
+
+When defining functions, you can define separate function bodies for different patterns.
+This leads to clean code that is simple and readable.
+You can pattern match on any data type — numbers, characters, lists, tuples, etc.
+
+For example, a trivial function that takes a whole number (`Int`) and makes it _1_ closer to _0_ could be expressed like this:
+
+```haskell
+closerToZero :: Int -> Int
+closerToZero 0 = 0
+closerToZero 1 = 0
+```
+
+Pattern matching starts to shine when used together with other patterns, for example the _variable pattern_:
+
+```haskell
+closerToZero :: Int -> Int
+closerToZero 0 = 0
+closerToZero n = n - 1
+```
+
+The above example treats all inputs other than _0_ the same, and would produce incorrect results for negative numbers.
+This can be solved using conditional patterns, known as _guards_, which are expressed with the `|` symbol:
+
+```haskell
+closerToZero :: Int -> Int
+closerToZero n
+    | n < 0 = n + 1
+    | n > 0 = n - 1
+```
+
+In the above examples not all possible inputs have a matching pattern.
+The compiler will detect this and output a warning.
+This is a very useful feature of Haskell that helps ensure all possible paths are covered to avoid run-time errors.
+It is known as _exhaustive checking_.
+To solve the warning, you have to handle all cases.
+Within _guards_ you can use the expression `otherwise` as syntactic sugar for `True` to catch all remaining patterns.
+
+```haskell
+closerToZero :: Int -> Int
+closerToZero n
+    | n < 0 = n + 1
+    | n > 0 = n - 1
+    | otherwise = 0
+```
+
+Pattern matching will test a value against each pattern from top to bottom, until it finds a matching pattern and executes the logic associated with that pattern.
+**The order of patterns matters!**
+
+[pattern-matching]: https://learnyouahaskell.github.io/syntax-in-functions#pattern-matching

exercises/concept/guessing-game/.docs/introduction.md.tpl

@@ -0,0 +1,3 @@
+# Introduction
+
+%{concept:pattern-matching-literals}

exercises/concept/guessing-game/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "blurb": "Learn about pattern matching by implementing a simple secret number guessing game",
+  "icon": "guessing-game",
+  "authors": [
+    "pwadsworth"
+  ],
+  "files": {
+    "solution": [
+      "src/GuessingGame.hs",
+      "package.yaml"
+    ],
+    "test": [
+      "test/Tests.hs"
+    ],
+    "exemplar": [
+      ".meta/exemplar/src/GuessingGame.hs"
+    ]
+  }
+}

exercises/concept/guessing-game/.meta/design.md

@@ -0,0 +1,25 @@
+# Design
+
+## Learning objectives
+
+- Know what [pattern matching][pattern-matching] is.
+- Know about constant, variable and wildcard patterns.
+- Know about guards.
+- Know about exhaustiveness checking in pattern matching.
+
+## Out of scope
+
+- Other patterns besides the constant and wildcard patterns.
+- Lazy pattern matching.
+- `case` statements.
+
+## Concepts
+
+- `pattern-matching`: know what [pattern matching][pattern-matching] is; know about constant, variable and wildcard patterns; know how to use guards; know about exhaustiveness checking in pattern matching.
+
+## Prerequisites
+
+- `basics`: function definitions
+- `numbers`: numeric types and operators
+
+[pattern-matching]: https://learnyouahaskell.github.io/syntax-in-functions#pattern-matching

exercises/concept/guessing-game/.meta/exemplar/package.yaml

@@ -0,0 +1,18 @@
+name: guessing-game
+version: 1.0.0.0
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: GuessingGame
+  source-dirs: src
+  ghc-options: -Wall
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - guessing-game
+      - hspec

exercises/concept/guessing-game/.meta/exemplar/src/GuessingGame.hs

@@ -0,0 +1,9 @@
+module GuessingGame (reply) where
+
+reply :: Int -> String
+reply 41 = "So close"
+reply 42 = "Correct"
+reply 43 = "So close"
+reply guess
+  | guess < 41 = "Too low"
+  | otherwise = "Too high"

exercises/concept/guessing-game/package.yaml

@@ -0,0 +1,18 @@
+name: guessing-game
+version: 1.0.0.0
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: GuessingGame
+  source-dirs: src
+  ghc-options: -Wall
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - guessing-game
+      - hspec

exercises/concept/guessing-game/src/GuessingGame.hs

@@ -0,0 +1,4 @@
+module GuessingGame (reply) where
+
+reply :: Int -> String
+reply guess = error "Implement this function."

exercises/concept/guessing-game/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-18.14

exercises/concept/guessing-game/test/Tests.hs

@@ -0,0 +1,16 @@
+import GuessingGame (reply)
+import Test.Hspec (describe, hspec, it, shouldBe)
+
+main :: IO ()
+main = hspec $
+  describe "reply" $ do
+    it "1 should be 'Too low'" $
+      reply 1 `shouldBe` "Too low"
+    it "100 should be 'Too high'" $
+      reply 100 `shouldBe` "Too high"
+    it "41 should be 'So close'" $
+      reply 41 `shouldBe` "So close"
+    it "43 should be 'So close'" $
+      reply 43 `shouldBe` "So close"
+    it "42 should be 'Correct'" $
+      reply 42 `shouldBe` "Correct"