Added exercises from https://github.com/tobiasgwaaler/hands-on-haskell

Author: tobiasgwaaler

exercises/BinTree/BinTree.hs

@@ -0,0 +1,106 @@
+module BinTree where
+
+{-
+    We're going to define functions that operate on a tree in order to use it
+    as a binary search tree, i.e. a tree where nodes have a value, and where a
+    node's left subtree consists of strictly smaller values that its own value,
+    and vice-versa for its right subtree.
+    First, let's define the data structure for a binary tree of Ints:
+-}
+
+data BinTree = Nil                       -- ← An empty tree
+             | Node Int BinTree BinTree  -- ← A node with an Int value and two
+             deriving (Eq, Show)         --   children, that are also BinTrees
+
+{-
+    To use our binary tree as a binary *search* tree we have to create
+    functions that make sure that the following invariants hold:
+
+    1. The left subtree of a node contains only nodes with values less than the
+       node's value.
+    2. The right subtree of a node contains only nodes with value greater than
+       the node's value.
+    3. There must be no duplicate nodes.
+
+    Let's look at how our data structure evolves when inserting the values 2,
+    3, 1, 4 in that order:
+
+    * Step 0: Empty tree:
+
+    Nil                                                   →        Nil
+
+    * Step 1: inserting 2 gives us:
+
+    Node 2 Nil Nil                                        →         2
+                                                                   / \
+                                                                 Nil Nil
+    * Step 2: inserting 3 gives us:
+
+    Node 2 Nil (Node 3 Nil Nil)                           →         2
+                                                                   / \
+                                                                 Nil  3
+                                                                     / \
+                                                                   Nil Nil
+    * Step 3: inserting 1 gives us:
+
+    Node 2 (Node 1 Nil Nil) (Node 3 Nil Nil)              →      __2__
+                                                                /      \
+                                                               1        3
+                                                              / \      / \
+                                                            Nil Nil  Nil Nil
+    * Step 4: inserting 4 gives us:
+
+    Node 2 (Node 1 Nil Nil) (Node 3 Nil (Node 4 Nil Nil)) →      __2__
+                                                                /      \
+                                                               1        3
+                                                              / \      / \
+                                                            Nil Nil  Nil  4
+                                                                         / \
+                                                                       Nil Nil
+
+    Ok. Let's build this insert function step by step. Its type will be the
+    following:
+-}
+
+insert :: Int -> BinTree -> BinTree
+
+{- The first case is inserting into an empty tree: -}
+
+insert n Nil = _YOUR_CODE_HERE
+
+{- ... the next case is inserting into a non-empty tree (i.e. a `Node`). We
+ need to find out whether to insert into the left or the right subtree. and
+ then our problem has been reduced to inserting a value into an BinTree again.
+ We (soon) have a function to do that, don't we..? :) -}
+
+insert n _YOUR_CODE_HERE {- code for matching a non-empty tree -} = _YOUR_CODE_HERE
+
+{-
+    Next, we're goint to create a function that does an in-order traversal of a
+    binary tree. An in-order travelsal means first traversing the left subtree
+    (smaller values), then a node's own value, and last its right subtree (larger
+    values). The result – if `insert` is correct – should be a sorted list.
+    Remembmer, to concatenate two lists, you can use the function (++):
+
+      [1,2,3] ++ [4] ++ [5,6] = [1,2,3,4,5,6]
+-}
+
+inorder :: BinTree -> [Int]
+inorder Nil = _YOUR_CODE_HERE -- What's the only value we can return here?
+inorder (Node value left right) = _YOUR_CODE_HERE
+
+{-
+    Bonus questions:
+
+    Our binary search tree is only for `Int`s – what would it take to
+    generalize it for any type `a`? Can our data type and the functions really
+    work for *any* type?
+
+    Change `BinTree`, `insert` and `inorder` so that they are no longer
+    Int-specific.
+
+    Can you think of reasons why this naïve BinTree might not be that great in
+    practice? :)
+-}
+
+_YOUR_CODE_HERE = undefined -- ignore me

exercises/BinTree/BinTreeSpec.hs

@@ -0,0 +1,30 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module BinTree.BinTreeSpec where
+
+import BinTree (BinTree (..))
+import qualified BinTree
+
+import Data.List (foldl', nub, sort)
+import qualified Test.QuickCheck as QC
+import Test.Hspec
+
+spec = do
+    describe "BinTree.insert" $
+        it "insert 1 into an empty tree" $
+            BinTree.insert (1 :: Int) Nil `shouldBe` Node 1 Nil Nil
+
+    describe "BinTree.insert" $
+        it "insert 2 1 3 4 into an empty tree" $
+            BinTree.insert (4 :: Int) (BinTree.insert 1 (BinTree.insert 3 (BinTree.insert 2 Nil)))
+              `shouldBe` Node 2 (Node 1 Nil Nil) (Node 3 Nil (Node 4 Nil Nil))
+
+    describe "BinTree.insert" $
+        it "make sure duplicates are ignored" $
+            BinTree.insert (3 :: Int) (BinTree.insert 1 (BinTree.insert 3 (BinTree.insert 2 Nil)))
+              `shouldBe` Node 2 (Node 1 Nil Nil) (Node 3 Nil Nil)
+
+    describe "BinTree.inorder" $
+        it "make sure an in-order traversal ouputs a sorted list" $
+            let propSorted (xs :: [Int]) = BinTree.inorder (foldl' (flip BinTree.insert) Nil xs) == (sort . nub) xs
+             in QC.quickCheck propSorted

exercises/Functions/Functions.hs

@@ -0,0 +1,86 @@
+module Functions where
+
+{-
+    In this module we will learn how to define and apply functions.
+-}
+
+
+-- Defining a function taking one parameter:
+welcome name = "Welcome, " ++ name ++ "."
+--  ^     ^    `------------^------------'
+-- name  parameter         body
+
+{-
+    There's no keyword like "def", "function" or anything preceding the name, just:
+    <functionName> <arguments> = <body>
+-}
+
+-- Calling a function with arguments
+welcomeSirOrMadam = welcome "Sir or Madam"
+
+{-
+    Now if we do multiple function applications and intend on passing the result
+    of the first application to the second application and so on, we would have to
+    use parentheses to remove abiguities:
+-}
+printWelcomeMessage2 = putStrLn (welcome "Welcome to the present")
+{-
+    otherwise the compiler would interpret that function this way:
+
+printWelcomeMessage2 = (putStrLn welcome) "Welcome to the present"
+                           ^        ^                 ^
+             function to apply     arg    arg to what (putstrln welcome) returned
+
+    So a general tip is: if in doubt, add parentheses!
+-}
+
+
+{-
+    Exercise:
+    Use the multiply function to return the product of 10 and 20.
+    Fill in your answer as the body of multiply10by20.
+-}
+-- This function returns the product of its arguments
+multiply arg1 arg2 = arg1 * arg2
+
+multiply10by20 = _YOUR_CODE_HERE
+
+
+{-
+    Exercise:
+    Define a function, plus, that takes two arguments and returns their sum
+-}
+plus :: Integer -> Integer -> Integer
+plus arg1 arg2 = _YOUR_CODE_HERE
+
+
+{-
+    Exercise:
+    Define a function, sum3, that takes 3 arguments and returns their sum.
+    ... and you must use the plus function to do so!
+-}
+sum3 :: Integer -> Integer -> Integer -> Integer
+sum3 arg1 arg2 arg3 = _YOUR_CODE_HERE
+
+
+{-
+    Exercise:
+    Define isDollar that takes a Char and returns
+    True only if that character is a dollar sign ($).
+-}
+isDollar :: Char -> Bool
+isDollar character = _YOUR_CODE_HERE
+
+
+{-
+    Exercise:
+    Define an "exclusive or" function: http://en.wikipedia.org/wiki/Exclusive_or#Truth_table
+    You probably want to use the following functions:
+
+    (&&) :: Bool -> Bool -> Bool
+    (||) :: Bool -> Bool -> Bool
+-}
+xor :: Bool -> Bool -> Bool
+xor arg1 arg2 = _YOUR_CODE_HERE
+
+_YOUR_CODE_HERE = undefined -- ignore me

exercises/Functions/FunctionsSpec.hs

@@ -0,0 +1,29 @@
+module Functions.FunctionsSpec where
+
+import qualified Functions
+
+import qualified Test.QuickCheck as QC
+import Test.Hspec
+
+spec = do
+    describe "Functions.multiply10by20" $
+        it "returns 200" $
+            Functions.multiply10by20 `shouldBe` 200
+
+    describe "Functions.plus" $
+        it "adds to *arbitrary* numbers" $
+            QC.property $ \x y -> Functions.plus x y == x + y
+
+    describe "Functions.sum3" $
+        it "adds three *arbitrary* numbers" $
+            QC.property $ \x y z -> Functions.sum3 x y z == x + y + z
+
+    describe "Functions.isDollar" $ do
+        it "returns true for '$'" $
+            Functions.isDollar '$' `shouldBe` True
+        it "returns false for anything but '$'" $
+            any Functions.isDollar ['%'..'z'] `shouldBe` False
+
+    describe "Functions.xor" $
+        it "is correct" $
+          QC.property $ \x y -> Functions.xor x y ==  (x && not y) || (y && not x)

exercises/HigherOrderFunctions/HigherOrderFunctions.hs

@@ -0,0 +1,75 @@
+module HigherOrderFunctions where
+
+{-
+    Now for some potentially mind blowing business: we're going to implement
+    sets of integers, as functions!
+    The idea is that a set is a boolean function for all integers, and
+    returns true if a given integer is part of the set and false otherwise.
+-}
+
+-- We create a type alias to avoid repetition of (Int -> Bool)
+type Set = (Int -> Bool)
+
+{-
+    Sets are then defined as functions that returns true/false based on the
+    number they're given.
+-}
+
+-- The set of even numbers
+evens :: Set
+evens n = n `mod` 2 == 0
+
+-- The set of positive numbers
+positives :: Set
+positives n = n > 0
+
+-- The set of numbers divisible by 3
+divBy3 :: Set
+divBy3 n = n `mod` 3 == 0
+
+-- The empty set
+emptySet :: Set
+emptySet _ = False
+
+{-
+    The lightness of sets as functions makes it very cheap to
+    combine them with set operators, such as intersect and union.
+-}
+
+-- The intersection of two sets is a function that returns a function that
+-- takes `x` and checks if it's a member of both sets.
+intersect :: Set -> Set -> Set
+intersect a b = \x -> let memberOfA = a x
+                          memberOfB = b x
+                       in memberOfA && memberOfB
+
+-- Combinations
+mySet1 = intersect evens divBy3
+
+{-
+    Exercise:
+    Write a function that returns a set containing only the provided argument.
+-}
+
+singleton :: Int -> Set
+singleton n = _YOUR_CODE_HERE
+
+{-
+    Exercise:
+    Write a function for set union.
+-}
+
+union :: Set -> Set -> Set
+union a b = _YOUR_CODE_HERE
+
+{-
+    Exercise:
+    Write a function for set difference. Given two sets a and b, the result
+    should be a set with only those numbers that appear in set a, but not is
+    set b.
+-}
+
+difference :: Set -> Set -> Set
+difference a b = _YOUR_CODE_HERE
+
+_YOUR_CODE_HERE = undefined -- ignore me

exercises/HigherOrderFunctions/HigherOrderFunctionsSpec.hs

@@ -0,0 +1,22 @@
+module HigherOrderFunctions.HigherOrderFunctionsSpec where
+
+import qualified HigherOrderFunctions    as HOF
+
+import qualified Test.QuickCheck as QC
+import Test.Hspec
+
+spec = do
+    describe "HigherOrderFunctions.singleton" $ do
+        it "should contain only the given number" $ do
+            map (HOF.singleton 3) [1,2,3,4] `shouldBe` [False, False, True, False]
+
+    describe "HigherOrderFunctions.union" $ do
+        let twoOrThree = HOF.singleton 3 `HOF.union` HOF.singleton 2
+            expected = 2
+            in it "should be the union of two sets" $ do
+              map twoOrThree [1,2,3,4] `shouldBe` [False, True, True, False]
+
+    describe "HigherOrderFunctions.difference" $ do
+        let evensExceptTwo = HOF.evens `HOF.difference` HOF.singleton 2
+         in it "should be the difference of two sets" $ do
+              map evensExceptTwo [1,2,3,4] `shouldBe` [False, False, False, True]