Boring types which contains one thing, also boring. There is nothing interesting to be gained by comparing one element of the boring type with another, because there is nothing to learn about an element of the boring type by giving it any of your attention.

Boring Law:

boring == x

Note: This is different class from Default. Default gives you some value, Boring gives you an unique value.

Also note, that we cannot have instances for e.g. Either, as both (Boring a, Absurd b) => Either a b and (Absurd a, Boring b) => Either a b would be valid instances.

Another useful trick, is that you can rewrite computations with Boring results, for example foo :: Int -> (), if you are sure that foo is total.

{-# RULES "less expensive" foo = boring #-}

That's particularly useful with equality :~: proofs.

The Absurd type is very exciting, because if somebody ever gives you a value belonging to it, you know that you are already dead and in Heaven and that anything you want is yours.

Similarly as there are many Boring sums, there are many Absurd products, so we don't have Absurd instances for tuples.

A helper class to implement Generic derivation of Boring.

Technically we could do (avoiding QuantifiedConstraints):

type GBoring f = (Boring (f V.Void), Functor f)

gboring :: forall f x. GBoring f => f x
gboring = vacuous (boring :: f V.Void)

but separate class is cleaner.

>>> data B2 = B2 () () deriving (Show, Generic)
>>> instance Boring B2
>>> boring :: B2
B2 () ()

A helper class to implement of Generic derivation of Absurd.

type GAbsurd f = (Absurd (f ()), Functor f)

gabsurd :: forall f x y. GAbsurd f => f x -> y
gabsurd = absurd . void

If Absurd is uninhabited then any Functor that holds only values of type Absurd is holding no values.

There is a field for every type in the Absurd. Very zen.

devoid :: Absurd s => Over p f s s a b

type Over p f s t a b = p a (f b) -> s -> f t

We can always retrieve a Boring value from any type.

united :: Boring a => Lens' s a