[Haskell-beginners] Need better explanation of the 'flipThree' example in LYAH

[Francesco Ariis]

Hello Olumide,

On Tue, Aug 21, 2018 at 01:04:01AM +0100, Olumide wrote:
> My understanding of what's going on here is sketchy at best. One of several
> explanations that I am considering is that all combination of a, b and c are
> evaluated in (==Tails) [a,b,c] but I cannot explain how the all function
> creates 'fuses' the list [f a, f b, f c]. I know that all f xs = and . map f
> xs (the definition on hackage is a lot more complicated) but, again, I
> cannot explain how the and function 'fuses' the list [f a, f b, f c].

Let's copy the relevant monad instance:

    instance Monad Prob where
        return x = Prob [(x,1%1)]
        m >>= f = flatten (fmap f m)

and desugar `flipThree:

    flipThree = coin       >>= \a ->
                coin       >>= \b ->
                loadedCoin >>= \c ->
                return (all (==Tails) [a,b,c])


Now it should be clearer: `coin >>= \a -> ...something...` takes `coin`
(Prob [(Heads,1%2),(Tails,1%2)]), applies a function (\a -> ...) to all
of its elements, flattens (probability wise) the result.
So approximately we have:

    1. some list ([a, b])
    2. nested lists after applying `\a -> ...` [[a1, a2], [b1, b2]]
    3. some more flattened list [a1, a2, b1, b2]

`\a -> ...` itself contains `\b ->` which cointains `\c ->`, those are
nested rounds of the same (>>=) trick we saw above.
At each time the intermediate result is bound to a variable (\a, \b
and \c), so for each triplet we can use `all`.

> If I'm on the right track I realize that I'm going to have to study the list
> the between list comprehensions and the do-notation in order how all the
> return function create one Prob.

Indeed I recall working the example on paper the first time I read it:
once you do it, it should stick!