Merge branch 'master' of https://github.com/tgdwyer/tgdwyer.github.io

Author: tgdwyer

_chapters/haskell3.md

@@ -869,7 +869,7 @@ This will allow us to make more functions point-free
 
 ```haskell
 square :: Num a => a => a
-square = a * a
+square a = a * a
 ```
 
 ```haskell
@@ -888,7 +888,7 @@ class Applicative f => Alternative (f :: * -> *) where
   (<|>) :: f a -> f a -> f a
 ```
 
-`empty`: This function represents a computation with *no result or a failure*. It serves as the identity element. For different data types that are instances of Alternative, `empty` represents an empty container or a *failed computation*, depending on the context.
+`empty`: This function represents a computation with either *no result, or a failure*. It serves as the identity element. For different data types that are instances of Alternative, `empty` represents an empty container or a *failed computation*, depending on the context.
 
 `(<|>)`: The `<|>` operator combines two computations, and it’s used to express alternatives. It takes two computations of the same type and returns a computation that will produce a result from the first computation if it succeeds, or if it fails, it will produce a result from the second computation. This operator allows you to handle branching logic and alternative paths in your code.
 

_chapters/haskell4.md

@@ -104,7 +104,7 @@ Note that since the `(+)` operator is associative—a+(b+c) = (a+b)+c—`foldr`
 
 ## Monoid
 
-In the example fold above, we provide the `(+)` function to tell `foldl` how to aggregate elements of the list.  There is also a typeclass for things that are “automatically aggregatable” or “concatenatable” called `Monoid` which declares a general function for `mappend` combining two `Monoid`s into one, a `mempty` value such that any Monoid `mappend`'ed with `mempty` is itself, and a concatenation function for lists of `Monoid` called `mconcat`.
+In the example fold above, we provide the `(+)` function to tell `foldl` how to aggregate elements of the list.  There is also a typeclass for things that are “automatically aggregable” or “concatenatable” called `Monoid` which declares a general function for `mappend` combining two `Monoid`s into one, a `mempty` value such that any Monoid `mappend`'ed with `mempty` is itself, and a concatenation function for lists of `Monoid` called `mconcat`.
 
 ```haskell
 Prelude> :i Monoid
@@ -133,7 +133,7 @@ Prelude Data.Monoid> getSum $ mconcat $ Sum <$> [5,8,3,1,7,6,2]
 
 > 32
 
-We make a data type aggregatable by instancing `Monoid` and providing definitions for the functions `mappend` and `mempty`.  For `Sum` these will be `(+)` and `0` respectively.
+We make a data type aggregable by instancing `Monoid` and providing definitions for the functions `mappend` and `mempty`.  For `Sum` these will be `(+)` and `0` respectively.
 Lists are also themselves Monoidal, with `mappend` defined as an alias for list concatenation `(++)`, and mempty as `[]`.  Thus, we can:
 
 ```haskell

_chapters/javascript1.md

@@ -1119,7 +1119,7 @@ class Person:
         self.occupation = occupation
 
     @property
-    def greeting():
+    def greeting(self):
        return f"Hi, my name's {self.name} and I {self.occupation}!"
 
     def say_hello(self):

_chapters/monad.md

@@ -399,7 +399,7 @@ they all take a common parameter, e.g. a line break character.
 ```haskell
 greet linebreak = "Dear Gentleperson,"++linebreak 
 body sofar linebreak = sofar ++ linebreak ++ "It has come to my attention that… " ++ linebreak
-signoff sofar linebreak = sofar ++ linebreak ++ "Your’s truly," ++ linebreak ++ "Tim" ++ linebreak
+signoff sofar linebreak = sofar ++ linebreak ++ "Yours truly," ++ linebreak ++ "Tim" ++ linebreak
 putStrLn $ (greet >>= body >>= signoff) "\r\n"
 ```
 

_chapters/parsercombinators.md

@@ -25,6 +25,57 @@ The parser combinator discussed here is based on one developed by Tony Morris an
 
 You can play with the example and the various parser bits and pieces in [this online playground](https://replit.com/@tgdwyer/Parser-Examples).
 
+## Why do we need Monads ?
+
+Consider the task of parsing the following string:
+
+```haskell
+5abcdefg
+```
+
+In this example, the number `5` specifies how many characters should be parsed from the rest of the string.
+The goal is to obtain the result:
+
+```haskell
+Just ("fg", "abcde")
+```
+
+The parser should first read the number 5, then use that value to determine how many characters to extract `"abcde"`, leaving the remainder `"fg"` unparsed. The key question here is: Can we achieve this using only `Functor` and `Applicative`?
+
+The answer is no. Both of these abstractions allow us to combine independent computations, but they do not allow one computation to depend on the result of another. Using a Monad, we can **sequence** computations where the output of one step influences the next step’s behavior, which is precisely what this parsing task requires.
+
+So, if we have these two parsers:
+
+```haskell
+parseInt :: Parser Int
+parseInt = int
+
+parseNCharacters :: Int -> Parser String
+parseNCharacters 0 = pure ""
+parseNCharacters n = liftA2 (:) char (parseNCharacters (n-1))
+```
+
+We want a way to combine these two parsers — first run `parseInt`, then pass its result to `parseNCharacters`. Let’s imagine a new operator that could do this:
+
+```haskell
+newOperator :: Parser Int -> (Int -> Parser String) -> Parser String
+```
+
+Using this operator, we could write:
+
+```haskell
+parse (newOperator parseInt parseNCharacters) "5abcdefg"
+  = Just ("fg", "abcde")
+```
+
+When we generalize this `newOperator` idea, to any container, we get:
+
+```haskell
+(>>=) :: f a -> (a -> f b) -> f b
+```
+
+This operator is called `bind`, and it is the core of the `Monad` type class. This is a very powerful concept, it allows you to chain dependent computations — where the output of one step determines the next step. This is exactly why `Monads` go beyond `Functors` and `Applicatives`: they enable sequencing with dependency.
+
 ## Context-free Grammars and BNF
 
 Fundamental to the analysis of human natural language but also to the design of programming languages is the idea of a *grammar*, or a set of rules for how elements of the language may be composed.  A context-free grammar (CFG) is one in which the set of rules for what is produced for a given input (*production rules*) completely covers the set of possible input symbols (i.e. there is no additional context required to parse the input).  Backus-Naur Form (or BNF) is a notation that has become standard for writing CFGs since the 1960s.  We will use BNF notation from now on.  There are two types of symbols in a CFG: *terminal* and *non-terminal*.  In BNF non-terminal symbols are `<nameInsideAngleBrackets>` and can be converted into a mixture of terminals and/or nonterminals by production rules: