# IsNull

A typeclass to determine if a given container is null.

Strongly inspired by
mono-traversable,
but with a simpler goal: supporting IsNull and nested IsNull operations.

Supported functions:

```
isNull :: a -> Bool
notNull :: a -> Bool
-- | Nested isNull
isNullN :: (Foldable f) => f a -> Bool
-- | Monadic isNull
isNullM :: Monad m => m a -> m Bool
-- | Monadic Nested isNull
isNullNM :: (Monad m, Foldable f) => m (f a) -> m Bool
-- | Alternative <|> operator does not always operate as choice,
-- at least not in an intuitive way (for example with lists).
-- This one does:
<\> :: a -> a -> a
```

The N stands for (non-recursive) nested, such that:

```
isNullN (Just "abc") == False
isNullN (Just "" ) == True
isNullN (Nothing ) == True
```

While the ```
`isNull function is equivalent to (==) mempty
for most of the instances, not all Foldables are monoids,
and not all monoids mempty
```

` means null:

``Either is an example of a Foldable`

` which is not a

```
`Monoid, but where it makes sense to consider a Left as
an 'Null' value. While this is not strictly true, the Left
```

`
option does carries a value, we take the more liberal approach:
Empty ~ Null ~ Invalid Value.
If you need proper type reasoning, you should not be using this
package, just regular pattern matching instead.

``Product Monoid instance is 1`

`. Hardly qualifies as an

```
`Empty or Null value. For this reason no default implementation
is provided for the Monoid
```

` class. It's up to you to use

``(==) mempty`

` instead.

Bugs, suggestions and comments are most welcomed!