-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Boring and Absurd types
--   
--   <ul>
--   <li><tt>Boring</tt> types are isomorphic to <tt>()</tt>.</li>
--   <li><tt>Absurd</tt> types are isomorphic to <tt>Void</tt>.</li>
--   </ul>
--   
--   See <a>What does () mean in Haskell -answer by Conor McBride</a>
@package boring
@version 0.1


-- | <a>Boring</a> and <a>Absurd</a> classes. One approach.
--   
--   Different approach would be to have
--   
--   <pre>
--   -- none-one-tons semiring
--   data NOT = None | One | Tons
--   
--   type family Cardinality (a :: *) :: NOT
--   
--   class Cardinality a ~ None =&gt; Absurd a where ...
--   class Cardinality a ~ One  =&gt; Boring a where ...
--   </pre>
--   
--   This would make possible to define more instances, e.g.
--   
--   <pre>
--   instance (Mult (Cardinality a) (Cardinality b) ~ None) =&gt; Absurd (a, b) where ...
--   </pre>
--   
--   <h3>Functions</h3>
--   
--   Function is an exponential:
--   
--   <pre>
--   Cardinality (a -&gt; b) ~ Exponent (Cardinality b) (Cardinality a)
--   </pre>
--   
--   or shortly <tt>|a -&gt; b| = |b| ^ |a|</tt>. This gives us possible
--   instances:
--   
--   <ul>
--   <li><tt>|a| = 0 =&gt; |a -&gt; b| = m ^ 0 = 1</tt>, i.e.
--   <tt><a>Absurd</a> a =&gt; <a>Boring</a> (a -&gt; b)</tt>, or</li>
--   <li><tt>|b| = 1 =&gt; |a -&gt; b| = 1 ^ n = 1</tt>, i.e.
--   <tt><a>Boring</a> b =&gt; <a>Boring</a> (a -&gt; b)</tt>.</li>
--   </ul>
--   
--   Both instances are <a>Boring</a>, but we chose to define the latter.
--   
--   <h3>Note about adding instances</h3>
--   
--   At this moment this module misses a lot of instances, please make a
--   patch to add more. Especially, if the package is already in the
--   transitive dependency closure.
--   
--   E.g. any possibly empty container <tt>f</tt> has <tt><a>Absurd</a> a
--   =&gt; <a>Boring</a> (f a)</tt>
module Data.Boring

-- | <a>Boring</a> types which contains one thing, also <a>boring</a>.
--   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.
--   
--   <i>Boring Law:</i>
--   
--   <pre>
--   <a>boring</a> == x
--   </pre>
--   
--   <i>Note:</i> This is different class from <tt>Default</tt>.
--   <tt>Default</tt> gives you <i>some</i> value, <tt>Boring</tt> gives
--   you an unique value.
--   
--   Also note, that we cannot have instances for e.g. <a>Either</a>, as
--   both <tt>(<a>Boring</a> a, <a>Absurd</a> b) =&gt; Either a b</tt> and
--   <tt>(<a>Absurd</a> a, <a>Boring</a> b) =&gt; Either a b</tt> would be
--   valid instances.
--   
--   Another useful trick, is that you can rewrite computations with
--   <a>Boring</a> results, for example <tt>foo :: Int -&gt; ()</tt>,
--   <b>if</b> you are sure that <tt>foo</tt> is <b>total</b>.
--   
--   <pre>
--   {-# RULES "less expensive" foo = boring #-}
--   </pre>
--   
--   That's particularly useful with equality <tt>:~:</tt> proofs.
class Boring a
boring :: Boring a => a

-- | The <a>Absurd</a> 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 <a>Boring</a> sums, there are many
--   <a>Absurd</a> products, so we don't have <a>Absurd</a> instances for
--   tuples.
class Absurd a
absurd :: Absurd a => a -> b

-- | If <a>Absurd</a> is uninhabited then any <a>Functor</a> that holds
--   only values of type <a>Absurd</a> is holding no values.
vacuous :: (Functor f, Absurd a) => f a -> f b

-- | If an index of <a>Representable</a> <tt>f</tt> is <a>Absurd</a>, <tt>f
--   a</tt> is <a>Boring</a>.
boringRep :: (Representable f, Absurd (Rep f)) => f a

-- | If an index of <a>Representable</a> <tt>f</tt> is <a>Boring</a>,
--   <tt>f</tt> is isomorphic to <a>Identity</a>.
--   
--   See also <tt>Settable</tt> class in <tt>lens</tt>.
untainted :: (Representable f, Boring (Rep f)) => f a -> a

-- | There is a field for every type in the <a>Absurd</a>. Very zen.
--   
--   <pre>
--   <a>devoid</a> :: <a>Absurd</a> s =&gt; Over p f s s a b
--   </pre>
--   
--   type Over p f s t a b = p a (f b) -&gt; s -&gt; f t
devoid :: Absurd s => p a (f b) -> s -> f s

-- | We can always retrieve a <a>Boring</a> value from any type.
--   
--   <pre>
--   <a>united</a> :: <a>Boring</a> a =&gt; Lens' s a
--   </pre>
united :: (Boring a, Functor f) => (a -> f a) -> s -> f s
instance Data.Boring.Absurd a => Data.Boring.Boring [a]
instance Data.Boring.Absurd a => Data.Boring.Boring (GHC.Base.Maybe a)
instance Data.Boring.Absurd Data.Void.Void
instance (Data.Boring.Absurd a, Data.Boring.Absurd b) => Data.Boring.Absurd (Data.Either.Either a b)
instance Data.Boring.Absurd a => Data.Boring.Absurd (Data.List.NonEmpty.NonEmpty a)
instance Data.Boring.Absurd a => Data.Boring.Absurd (Data.Stream.Infinite.Stream a)
instance Data.Boring.Absurd a => Data.Boring.Absurd (Data.Functor.Identity.Identity a)
instance Data.Boring.Absurd (f (g a)) => Data.Boring.Absurd (Data.Functor.Compose.Compose f g a)
instance (Data.Boring.Absurd (f a), Data.Boring.Absurd (g a)) => Data.Boring.Absurd (Data.Functor.Sum.Sum f g a)
instance Data.Boring.Absurd b => Data.Boring.Absurd (Data.Functor.Const.Const b a)
instance Data.Boring.Absurd a => Data.Boring.Absurd (Data.Tagged.Tagged b a)
instance Data.Boring.Absurd a => Data.Boring.Absurd (Generics.SOP.BasicFunctors.I a)
instance Data.Boring.Absurd b => Data.Boring.Absurd (Generics.SOP.BasicFunctors.K b a)
instance n ~ 'Data.Nat.Z => Data.Boring.Absurd (Data.Fin.Fin n)
instance Data.Boring.Boring ()
instance Data.Boring.Boring b => Data.Boring.Boring (a -> b)
instance Data.Boring.Boring (Data.Proxy.Proxy a)
instance Data.Boring.Boring a => Data.Boring.Boring (Data.Functor.Const.Const a b)
instance Data.Boring.Boring b => Data.Boring.Boring (Data.Tagged.Tagged a b)
instance Data.Boring.Boring a => Data.Boring.Boring (Data.Functor.Identity.Identity a)
instance Data.Boring.Boring a => Data.Boring.Boring (Generics.SOP.BasicFunctors.I a)
instance Data.Boring.Boring b => Data.Boring.Boring (Generics.SOP.BasicFunctors.K b a)
instance Data.Boring.Boring (f (g a)) => Data.Boring.Boring (Data.Functor.Compose.Compose f g a)
instance (Data.Boring.Boring (f a), Data.Boring.Boring (g a)) => Data.Boring.Boring (Data.Functor.Product.Product f g a)
instance c => Data.Boring.Boring (Data.Constraint.Dict c)
instance (Data.Boring.Boring a, Data.Boring.Boring b) => Data.Boring.Boring (a, b)
instance (Data.Boring.Boring a, Data.Boring.Boring b, Data.Boring.Boring c) => Data.Boring.Boring (a, b, c)
instance (Data.Boring.Boring a, Data.Boring.Boring b, Data.Boring.Boring c, Data.Boring.Boring d) => Data.Boring.Boring (a, b, c, d)
instance (Data.Boring.Boring a, Data.Boring.Boring b, Data.Boring.Boring c, Data.Boring.Boring d, Data.Boring.Boring e) => Data.Boring.Boring (a, b, c, d, e)
instance Data.Boring.Boring a => Data.Boring.Boring (Data.Stream.Infinite.Stream a)
instance a ~ b => Data.Boring.Boring (a Data.Type.Equality.:~: b)
instance n ~ 'Data.Nat.Z => Data.Boring.Boring (Data.Vec.Lazy.Vec n a)
instance n ~ 'Data.Nat.Z => Data.Boring.Boring (Data.Vec.Pull.Vec n a)
instance n ~ 'Data.Nat.S 'Data.Nat.Z => Data.Boring.Boring (Data.Fin.Fin n)