tests for Monad Comprehensions and backtracking (#374)

* tests for Monad Comprehensions and backtracking

* added dependency

Author: marcellourbani

Diff for: exercises/chapter11/spago.dhall

@@ -4,7 +4,8 @@ You can edit this file as you like.
 -}
 { name = "my-project"
 , dependencies =
-  [ "console"
+  [ "arrays" 
+  , "console"
   , "control"
   , "effect"
   , "either"

Diff for: exercises/chapter11/test/Main.purs

@@ -1,6 +1,6 @@
 module Test.Main where
 
-import Prelude
+import Prelude (Unit, discard, ($), (<>))
 
 import Test.MySolutions
 import Test.NoPeeking.Solutions  -- Note to reader: Delete this line
@@ -102,5 +102,32 @@ Note to reader: Delete this line to expand comment block -}
                   indent' $ do
                     line' "I am even more indented"
 
+    suite "Exercises Group - Monad Comprehensions/backtracking" do
+      suite "parser" do
+        let
+          runParser p s = unwrap $ runExceptT $ runWriterT $ runStateT p s
+        test "should parse as followed by bs" do
+          Assert.equal (Right (Tuple (Tuple "aaabb" "cde") [
+            "The state is aaabbcde",
+            "The state is aabbcde",
+            "The state is abbcde",
+            "The state is bbcde",
+            "The state is bcde"]))
+            $ runParser asFollowedByBs "aaabbcde"
+        test "should fail if first is not a" do
+          Assert.equal (Left ["Could not parse"])
+            $ runParser asFollowedByBs "bfoobar"
+        test "should parse as and bs" do
+          Assert.equal (Right (Tuple (Tuple "babbaa" "cde") [
+            "The state is babbaacde",
+            "The state is abbaacde",
+            "The state is bbaacde",
+            "The state is baacde",
+            "The state is aacde",
+            "The state is acde"]))
+            $ runParser asOrBs "babbaacde"
+        test "should fail if first is not a or b" do
+          Assert.equal (Left ["Could not parse","Could not parse"])
+            $ runParser asOrBs "foobar"
 {- Note to reader: Delete this line to expand comment block
 -}

Diff for: exercises/chapter11/test/no-peeking/Solutions.purs

@@ -2,10 +2,13 @@ module Test.NoPeeking.Solutions where
 
 import Prelude
 
+import Control.Alt ((<|>))
 import Control.Monad.Except (ExceptT, throwError)
 import Control.Monad.Reader (Reader, ReaderT, ask, lift, local, runReader, runReaderT)
 import Control.Monad.State (State, StateT, get, put, execState, modify_)
 import Control.Monad.Writer (Writer, WriterT, tell, runWriter, execWriterT)
+import Data.Array (some)
+import Data.Foldable (fold)
 import Data.Identity (Identity)
 import Data.Maybe (Maybe(..))
 import Data.Monoid (power)
@@ -112,3 +115,12 @@ indent' = local $ (+) 1
 
 render' :: Doc' -> String
 render' doct = joinWith "\n" $ unwrap $ runReaderT (execWriterT doct) 0
+
+asFollowedByBs ::  Parser String
+asFollowedByBs = do
+  as <- some $ string "a"
+  bs <- some $ string "b"
+  pure $ fold $ as <> bs
+
+asOrBs :: Parser String
+asOrBs = fold <$> some (string "a" <|> string "b")

Diff for: text/chapter11.md

@@ -731,8 +731,8 @@ Again, this illustrates the power of reusability that monad transformers bring -
  ## Exercises
 
  1. (Easy) Remove the calls to the `lift` function from your implementation of the `string` parser. Verify that the new implementation type checks, and convince yourself that it should.
- 1. (Medium) Use your `string` parser with the `many` combinator to write a parser which recognizes strings consisting of several copies of the string `"a"` followed by several copies of the string `"b"`.
- 1. (Medium) Use the `<|>` operator to write a parser which recognizes strings of the letters `a` or `b` in any order.
+ 1. (Medium) Use your `string` parser with the `many` combinator to write a parser `asFollowedByBs` which recognizes strings consisting of several copies of the string `"a"` followed by several copies of the string `"b"`.
+ 1. (Medium) Use the `<|>` operator to write a parser `asOrBs` which recognizes strings of the letters `a` or `b` in any order.
  1. (Difficult) The `Parser` monad might also be defined as follows:
 
      ```haskell