Resuming My Journey Toward an Understanding of Haskell Monads (Yet Again)

data Car = Car {company :: String, model :: String, year :: Int} deriving (Show)  

carAge :: Car -> Int
carAge car = 2019 - year car    -- Hard-coding current year, so what?

ghci> Car {company="Ford", model="Mustang", year=1967}  
Car {company = "Ford", model = "Mustang", year = 1967}

λ *Car> :t year
year :: Car -> Int

Each of the "fields" is actually a function that returns the value of that field. (See the use of year in carAge.)

instance Applicative Maybe where
    pure = Just
    Nothing <*> _ = Nothing
    (Just f) <*> something = fmap f something

instance Applicative [] where
    pure x = [x]
    fs <*> xs = [f x | f <- fs, x <- xs]

"Cross product" of list of functions with list of values.

instance Applicative IO where
    pure = return
    a <*> b = do
        f <- a
        x <- b
        return (f x)

instance Applicative ((->) r) where
    pure x = (\_ -> x)
    f <*> g = \x -> f x (g x)

λ Prelude> (+) <$> (3+) <*> (100*) $ 5
508

λ Prelude> (\x y z -> [x,y,z]) <$> (3+) <*> (2*) <*> (/2) $ 5
[8.0,10.0,2.5]

λ Prelude> :t (\x y z -> [x,y,z])
(\x y z -> [x,y,z]) :: t -> t -> t -> [t]

λ Prelude> :t (\x y z -> [x,y,z]) <$> (3+) 
(\x y z -> [x,y,z]) <$> (3+) :: Num t => t -> t -> t -> [t]

λ Prelude> :t (\x y z -> [x,y,z]) <$> (3+) <*> (2*)
(\x y z -> [x,y,z]) <$> (3+) <*> (2*) :: Num a => a -> a -> [a]

λ Prelude> :t (\x y z -> [x,y,z]) <$> (3+) <*> (2*) <*> (2-)
(\x y z -> [x,y,z]) <$> (3+) <*> (2*) <*> (2-) :: Num a => a -> [a]

The only thing that matters here is the type of the return value of the function: [a], in the latter case. So, because precedence is the same for <$> and <*>, and they're both left-associative, we apply them from left to right and get different-arity functions each time, but we don't care, because the return type is always [a].

So, in the case of (\x y z -> [x,y,z]) <$> (3+), the input is a plain function. It happens to take a t and return something scary (a 2-arg function that returns a list), but we don't care, it's a plan function.

Then we apply that lambda with <$> to (3+) and we get something else horrific (a 3-arg function that returns a list), but we don't care, because it ends with "returns a list", which is that ( (->) r) we started with, so we're happy, we're in Functor-land.

We keep tacking on <*> operators (with right-hand operands), and we keep getting functions that return [a], so we're still in the same Functor.

Eventually, we get down to a function that takes a single argument and returns a list, and we apply that function to a number (5).

In execution, in the definition of Applicative for the case of functions, f <*> g above, we have this weird syntax, f x (g x). f and g are both functions that return an r (a list of a's, in this case). We apply f to x and the result is a function, and then we apply that function to the result of g x. So, applying f to x basically "eats" an argument, producing a function of one less argument than f had (but also at least one argument that can be the result of g x).

So, the question "how many <*>s can we have?" is "as many as are necessary to satisfy the function on the left side of <$>". Actually, we need exactly that many.

Most important.

(f is a function here, I believe.)

Breakdown:

pure f returns your applicative functor (the one you're defining when you implement pure) containing the function f.

Then, <*> is used to apply the applicative functor to x. That should be the same as calling fmap f x.

pure id <*> v = v
pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
pure f <*> pure x = pure (f x)
u <*> pure y = pure ($ y) <*> u

When pattern matching fails in a do expression, the fail function is called. It's part of the Monad type class and it enables failed pattern matching to result in a failure in the context of the current monad instead of making our program crash. Its default implementation is this:

fail :: (Monad m) => String -> m a  
fail msg = error msg

So by default it does make our program crash, but monads that incorporate a context of possible failure (like Maybe) usually implement it on their own. For Maybe, its implemented like so:

fail _ = Nothing

In the following:

wopwop :: Maybe Char  
wopwop = do  
    (x:xs) <- Just ""   -- pattern match will fail
    return x 

We wind up injecting Nothing, so the attempt to invoke return x is short-circuited by the Nothing (because of the implicit ">>=" between each line).

Note that, for the List monad, failure is an empty list, and the attempt to use ">>=" on an empty list will return an empty list, no matter what function we're attempting to apply. (See Knight's Quest, below.)

instance Functor [] where  
    fmap = map  

instance Applicative [] where  
    pure x = [x]  
    fs <*> xs = [f x | f <- fs, x <- xs]  

f is the a -> b part of the Applicative definition. In the following definition

(<*>) :: fr (a -> b) -> fr a -> fr b

fr is the "list-ifier" []. So, we have a list of functions (a -> b), and a list of a's, and the result is a list of b's, where each b is generated by applying one of the f's to one of the a's.

So, it's kind of a cross-product between functions and arguments.

instance Monad [] where  
    return x = [x]  
    xs >>= f = concat (map f xs)  
    fail _ = []  

(>>) has a default implementation:

(>>) :: m a -> m b -> m b
x >> y = x >>= \_ -> y

So, in the definition of class Monad, m a is a list of a's. And f is a function from a single a to a list of results (a -> m b). Since we apply a function that generates a list to a list of arguments (m a is [a]), we wind up with a list of lists, so we use concat to flatten them out into a single list.

So, if the input m a (a.k.a. xs) is the empty list (which is the same as fail, I guess), the result will also be the empty list, no matter what f is.

Finally, for >>, if the "input" x is the empty list (fail, again, I guess), then the function \_ -> y applied to the empty list will be the empty list, not a bunch of y's (or even a single one). It doesn't matter that the function doesn't care about its input (_), there's nothing to apply it to.

instance MonadPlus [] where  
    mzero = []  
    mplus = (++)  

(Kind of duh.)

guard :: (MonadPlus m) => Bool -> m ()  
guard True = return ()  
guard False = mzero  

All default implementations. The interpretation for List:

m () : m is List, so m () is really [()].

return is like pure: a "minimal wrapping" of its argument. In this case, return () is really [()], a list containing a single empty tuple (the empty tuple, () is also known as "unit").

mzero is just the empty list.

So, for Lists, guard returns either [()] or just [].

moveKnight :: KnightPos -> [KnightPos]  
moveKnight (c,r) = filter onBoard  
    [(c+2,r-1),(c+2,r+1),(c-2,r-1),(c-2,r+1)  
    ,(c+1,r-2),(c+1,r+2),(c-1,r-2),(c-1,r+2)  
    ]  
    where onBoard (c,r) = c `elem` [1..8] && r `elem` [1..8]  

But it doesn't make any difference.