typos

Author: MatthijsBlom

source_md/for-a-few-monads-more.md

@@ -1221,7 +1221,7 @@ So it's kind of like `fmap`, only the function itself is in a context.
 We have to somehow extract it from the context and map it over the `f a` value and then assemble the context back together.
 Because all functions are curried in Haskell by default, we can use the combination of `<$>` and `<*>` to apply functions that take several parameters between applicative values.
 
-Anyway, it turns out that just like `fmap`, `<*>` can also be implemented by using only what the `Monad` type class give us.
+Anyway, it turns out that just like `fmap`, `<*>` can also be implemented by using only what the `Monad` type class gives us.
 The `ap` function is basically `<*>`, only it has a `Monad` constraint instead of an `Applicative` one.
 Here's its definition:
 

source_md/higher-order-functions.md

@@ -165,7 +165,7 @@ The second parameter is something of that type also and the return value is also
 We could read this type declaration in the curried way, but to save ourselves a headache, we'll just say that this function takes two parameters and returns one thing.
 The first parameter is a function (of type `a -> a`) and the second is that same `a`.
 The function can also be `Int -> Int` or `String -> String` or whatever.
-But then, the second parameter to also has to be of that type.
+But then, the second parameter has to also be of that type.
 
 ::: {.hintbox}
 **Note:** From now on, we'll say that functions take several parameters despite each function actually taking only one parameter and returning partially applied functions until we reach a function that returns a solid value.
@@ -248,7 +248,7 @@ flip' f = g
     where g x y = f y x
 ```
 
-Reading the type declaration, we say that it takes a function that takes an `a` and a `b` and returns a function that takes a `b` and an `a`.
+Reading the type declaration, we see that it takes a function that takes an `a` and a `b` and returns a function that takes a `b` and an `a`.
 But because functions are curried by default, the second pair of parentheses is really unnecessary, because `->` is right associative by default.
 `(a -> b -> c) -> (b -> a -> c)` is the same as `(a -> b -> c) -> (b -> (a -> c))`, which is the same as `(a -> b -> c) -> b -> a -> c`.
 We wrote that `g x y = f y x`.
@@ -336,7 +336,7 @@ ghci> filter (`elem` ['A'..'Z']) "i Laugh At you Because u R All The Same"
 ```
 
 All of this could also be achieved with list comprehensions by the use of predicates.
-There's no set rule for when to use `map` and `filter` versus using list comprehension, you just have to decide what's more readable depending on the code and the context.
+There's no set rule for when to use `map` and `filter` versus using a list comprehension, you just have to decide what's more readable depending on the code and the context.
 The `filter` equivalent of applying several predicates in a list comprehension is either filtering something several times or joining the predicates with the logical `&&` function.
 
 Remember our quicksort function from the [previous chapter](recursion.html)?

source_md/making-our-own-types-and-typeclasses.md

@@ -119,8 +119,8 @@ Value constructors are functions, so we can map them and partially apply them an
 If we want a list of concentric circles with different radii, we can do this.
 
 ```{.haskell:hs}
-ghci> map (Circle 10 20) [4,5,6,6]
-[Circle 10.0 20.0 4.0,Circle 10.0 20.0 5.0,Circle 10.0 20.0 6.0,Circle 10.0 20.0 6.0]
+ghci> map (Circle 10 20) [4,5,6,7]
+[Circle 10.0 20.0 4.0,Circle 10.0 20.0 5.0,Circle 10.0 20.0 6.0,Circle 10.0 20.0 7.0]
 ```
 
 Our data type is good, although it could be better.
@@ -1871,7 +1871,8 @@ data Frank a b  = Frank {frankField :: b a} deriving (Show)
 How do we know this type has a kind of `k -> (k -> *) - > *`?
 Well, fields in ADTs are made to hold values, so they must be of kind `*`, obviously.
 We assume `k` for `a`, and `b` takes it as its argument so its kind is `k -> *`.
-Now we know the kinds of both `a` and `b` and because they're parameters for `Frank`, we see that `Frank` has a kind of `k -> (k -> *) -> *` The first `k` represents `a` and the `(k -> *)` represents `b`.
+Now we know the kinds of both `a` and `b` and because they're parameters for `Frank`, we see that `Frank` has a kind of `k -> (k -> *) -> *`.
+The first `k` represents `a` and the `(k -> *)` represents `b`.
 Let's make some `Frank` values and check out their types.
 
 ```{.haskell:hs}

source_md/modules.md

@@ -408,7 +408,7 @@ find :: (a -> Bool) -> [a] -> Maybe a
 
 Notice the type of `find`.
 Its result is `Maybe a`.
-That's kind of like having the type of `[a]`, only a value of the type `Maybe` can contain either no elements or one element, whereas a list can contain no elements, one element or several elements.
+That's kind of like having the type of `[a]`, only a value of the type `Maybe a` can contain either no elements or one element, whereas a list can contain no elements, one element or several elements.
 
 Remember when we were searching for the first time our stock went over $1000.
 We did `head (dropWhile (\(val,y,m,d) -> val < 1000) stock)`.
@@ -559,7 +559,7 @@ ghci> [1..7] `intersect` [5..10]
 ```
 
 `insert`{.label .function} takes an element and a list of elements that can be sorted and inserts it into the last position where it's still less than or equal to the next element.
-In other words, `insert` will start at the beginning of the list and then keep going until it finds an element that's equal to or greater than the element that we're inserting and it will insert it just before the element.
+In other words, `insert` will start at the beginning of the list and then keep going until it finds an element that's equal to or greater than the element that we're inserting and it will insert it just before that element.
 
 ```{.haskell:ghci}
 ghci> insert 4 [3,5,1,2,8,2]
@@ -743,7 +743,7 @@ ghci> filter (not . any isSpace) . groupBy ((==) `on` isSpace) $ "hey folks its
 
 Ah.
 
-The `Data.Char` also exports a datatype that's kind of like `Ordering`.
+The `Data.Char` module also exports a datatype that's kind of like `Ordering`.
 The `Ordering` type can have a value of `LT`, `EQ` or `GT`.
 It's a sort of enumeration.
 It describes a few possible results that can arise from comparing two elements.
@@ -798,7 +798,7 @@ ghci> intToDigit 5
 '5'
 ```
 
-The `ord`{.label .function} and `chr` functions convert characters to their corresponding numbers and vice versa:
+The `ord`{.label .function} and `chr`{.label .function} functions convert characters to their corresponding numbers and vice versa:
 
 ```{.haskell:ghci}
 ghci> ord 'a'
@@ -960,7 +960,7 @@ fromList [(1,2),(3,2),(5,5)]
 ```
 
 If there are duplicate keys in the original association list, the duplicates are just discarded.
-This is the type signature of `fromList`
+This is the type signature of `fromList`:
 
 ```{.haskell:hs}
 Map.fromList :: (Ord k) => [(k, v)] -> Map.Map k v