This isn't _really_ useful, since we're still pattern matching on a type that looks

identical to `Maybe` itself. There is one reason that I bring it up, though. Remember

how `foldr` was equivalent to `cata` for `MyList`, because defining a function `MyListF a -> a` was

the same as providing a base case `a` and a "combining function" `Int -> a -> a`? Well,

defining a function `MaybeF x a -> a` is the same as providing a base case `a` (for `NothingF`)

and a handler for the contained value, `x -> a`. So we might imagine the `foldr` function for `Maybe`

to have type:

```Haskell

maybeFold :: a -> (x -> a) -> Maybe x -> a

```

This is exactly the function [`maybe` from `Data.Maybe`](https://hackage.haskell.org/package/base-4.16.1.0/docs/Data-Maybe.html#v:maybe)! Hopefully you can follow a similar process in your head to arrive at "fold"

functions for `Either` and `Bool`. Indeed, there are functions that correspond to these data types

in the Haskell standard library, named [`either`](https://hackage.haskell.org/package/base-4.16.1.0/docs/Data-Either.html#v:either) and [`bool`](https://hackage.haskell.org/package/base-4.16.1.0/docs/Data-Bool.html#v:bool).

Much like `fold` can be used to represent any function on lists, `maybe`, `either`, and `bool` can be

used to represent any function on their corresponding data types. I think that's neat.

#### What About `Foldable`?

If you've been around the Haskell ecosystem, you may know the `Foldable` type class.

Isn't this exactly what we've been working towards here? No, not at all. Take