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


-- | Overloaded pragmas as a plugin
--   
--   Implement <tt>Overloaded</tt> pragmas as a source plugin
--   
--   For example we can replace
--   
--   <pre>
--   {-# LANGUAGE OverloadedStrings #-}
--   </pre>
--   
--   with
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Strings #-}
--   </pre>
@package overloaded
@version 0.3


-- | Overloaded Categories, desugar <tt>Arrow</tt> into classes in this
--   module.
--   
--   <h2>Enabled with</h2>
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Categories #-}
--   </pre>
--   
--   <h2>Description</h2>
--   
--   <tt>Arrows</tt> notation - <a>GHC manual chapter</a> - is cool, but it
--   desugars into <i>"wrong"</i> classes. The <tt>arr</tt> combinator is
--   used for plumbing. We should desugar to proper type-classes:
--   
--   <ul>
--   <li><a>CartesianCategory</a>, not <a>Arrow</a></li>
--   <li><a>CocartesianCategory</a>, not <a>ArrowChoice</a> (implementation
--   relies on <a>BicartesianCategory</a>)</li>
--   <li><a>CCC</a>, not <a>ArrowApply</a> (not implemented yet)</li>
--   </ul>
--   
--   <h2>Examples</h2>
--   
--   Expression like
--   
--   <pre>
--   catAssoc
--       :: <a>CartesianCategory</a> cat
--       =&gt; cat (<a>Product</a> cat (<a>Product</a> cat a b) c) (<a>Product</a> cat a (<a>Product</a> cat b c))
--   catAssoc = proc ((x, y), z) -&gt; <a>identity</a> -&lt; (x, (y, z))
--   </pre>
--   
--   are desugared to (a mess which is)
--   
--   <pre>
--   <a>fanout</a> (<a>proj1</a> <a>%%</a> <a>proj1</a>) (<a>fanout</a> (<a>proj2</a> <a>%%</a> <a>proj1</a>) <a>proj2</a>)
--   </pre>
--   
--   If you are familiar with arrows-operators, this is similar to
--   
--   <pre>
--   (<a>fst</a> . <a>fst</a>) <tt>&amp;&amp;&amp;</tt> (<a>snd</a> . <a>fst</a> <tt>&amp;&amp;&amp;</tt> <a>snd</a>)
--   </pre>
--   
--   expression.
--   
--   The <tt>catAssoc</tt> could be instantiated to <tt>cat = (-&gt;)</tt>,
--   or more interestingly for example instantiate it to STLC morphisms to
--   get an expression like:
--   
--   <pre>
--   Lam (Pair (Fst (Fst (Var Here))) (Pair (Snd (Fst (Var Here))) (Snd (Var Here))))
--   </pre>
--   
--   <tt>proc</tt> notation is nicer than writing de Bruijn indices.
--   
--   This is very similar idea to Conal Elliott's <a>Compiling to
--   Categories</a> work. This approach is syntactically more heavy, but
--   works in more correct stage of compiler, before actual desugarer.
--   
--   As one more example, we implement the automatic differentiation, as in
--   Conal's paper(s). To keep things simple we use
--   
--   <pre>
--   newtype AD a b = AD (a -&gt; (b, a -&gt; b))
--   </pre>
--   
--   representation, i.e. use ordinary maps to represent linear maps. We
--   then define a function
--   
--   <pre>
--   evaluateAD :: Functor f =&gt; AD a b -&gt; a -&gt; f a -&gt; (b, f b)
--   evaluateAD (AD f) x xs = let (y, f') = f x in (y, fmap f' xs)
--   </pre>
--   
--   which would allow to calculuate function value and derivatives in
--   given directions. Then we can define simple quadratic function:
--   
--   <pre>
--   quad :: AD (Double, Double) Double
--   quad = proc (x, y) -&gt; do
--       x2 &lt;- mult -&lt; (x, x)
--       y2 &lt;- mult -&lt; (y, y)
--       plus -&lt; (x2, y2)
--   </pre>
--   
--   It's not as simple as writing <tt>quad x y = x * x + y * y</tt>, but
--   not <i>too far</i>.
--   
--   Then we can play with it. At origo everything is zero:
--   
--   <pre>
--   let sqrthf = 1 / sqrt 2
--   in evaluateAD quad (0, 0) [(1,0), (0,1), (sqrthf, sqrthf)] = (0.0,[0.0,0.0,0.0])
--   </pre>
--   
--   If we evaluate at some other point, we see things working:
--   
--   <pre>
--   evaluateAD quad (1, 2) [(1,0), (0,1), (sqrthf, sqrthf)] = (5.0,[2.0,4.0,4.242640687119285])
--   </pre>
--   
--   Obviously, if we would use inspectable representation for linear maps,
--   as Conal describe, we'd get more benefits. And then <tt>arr</tt>
--   wouldn't be definable!
module Overloaded.Categories

-- | A class for categories. Instances should satisfy the laws
--   
--   <ul>
--   <li><i>Right identity</i> <tt>f <a>.</a> <a>id</a> = f</tt></li>
--   <li><i>Left identity</i> <tt><a>id</a> <a>.</a> f = f</tt></li>
--   <li><i>Associativity</i> <tt>f <a>.</a> (g <a>.</a> h) = (f <a>.</a>
--   g) <a>.</a> h</tt></li>
--   </ul>
class Category (cat :: k -> k -> Type)

-- | A non-clashing name for <a>id</a>.
identity :: Category cat => cat a a

-- | A non-clashing name for <tt>(<a>.</a>)</tt>.
(%%) :: Category cat => cat b c -> cat a b -> cat a c
infixr 9 %%
class Category cat => SemigroupalCategory (cat :: k -> k -> Type) where {
    type family Tensor cat :: k -> k -> k;
}
assoc :: SemigroupalCategory cat => cat (Tensor cat (Tensor cat a b) c) (Tensor cat a (Tensor cat b c))
unassoc :: SemigroupalCategory cat => cat (Tensor cat a (Tensor cat b c)) (Tensor cat (Tensor cat a b) c)
defaultAssoc :: (CartesianCategory cat, Tensor cat ~ Product cat) => cat (Tensor cat (Tensor cat a b) c) (Tensor cat a (Tensor cat b c))
defaultUnassoc :: (CartesianCategory cat, Tensor cat ~ Product cat) => cat (Tensor cat a (Tensor cat b c)) (Tensor cat (Tensor cat a b) c)
class SemigroupalCategory cat => MonoidalCategory (cat :: k -> k -> Type) where {
    type family Unit cat :: k;
}
lunit :: MonoidalCategory cat => cat (Tensor cat (Unit cat) a) a
runit :: MonoidalCategory cat => cat (Tensor cat a (Unit cat)) a
unlunit :: MonoidalCategory cat => cat a (Tensor cat (Unit cat) a)
unrunit :: MonoidalCategory cat => cat a (Tensor cat a (Unit cat))
defaultLunit :: (CartesianCategory cat, Tensor cat ~ Product cat) => cat (Tensor cat (Unit cat) a) a
defaultRunit :: (CartesianCategory cat, Tensor cat ~ Product cat) => cat (Tensor cat a (Unit cat)) a
defaultUnrunit :: (CategoryWith1 cat, Tensor cat ~ Product cat, Unit cat ~ Terminal cat) => cat a (Tensor cat a (Unit cat))
defaultUnlunit :: (CategoryWith1 cat, Tensor cat ~ Product cat, Unit cat ~ Terminal cat) => cat a (Tensor cat (Unit cat) a)
class SemigroupalCategory cat => CommutativeCategory cat
swap :: CommutativeCategory cat => cat (Tensor cat a b) (Tensor cat b a)
defaultSwap :: (CartesianCategory cat, Tensor cat ~ Product cat) => cat (Tensor cat a b) (Tensor cat b a)

-- | Cartesian category is a monoidal category where monoidal product is
--   the categorical product.
class Category cat => CartesianCategory (cat :: k -> k -> Type) where {
    type family Product cat :: k -> k -> k;
}
proj1 :: CartesianCategory cat => cat (Product cat a b) a
proj2 :: CartesianCategory cat => cat (Product cat a b) b

-- | <tt><a>fanout</a> f g</tt> is written as &lt;math&gt; in category
--   theory literature.
fanout :: CartesianCategory cat => cat a b -> cat a c -> cat a (Product cat b c)

-- | Category with terminal object.
class CartesianCategory cat => CategoryWith1 (cat :: k -> k -> Type) where {
    type family Terminal cat :: k;
}
terminal :: CategoryWith1 cat => cat a (Terminal cat)

-- | Category with initial object.
class CocartesianCategory cat => CategoryWith0 (cat :: k -> k -> Type) where {
    type family Initial cat :: k;
}
initial :: CategoryWith0 cat => cat (Initial cat) a

-- | Cocartesian category is a monoidal category where monoidal product is
--   the categorical coproduct.
class Category cat => CocartesianCategory (cat :: k -> k -> Type) where {
    type family Coproduct cat :: k -> k -> k;
}
inl :: CocartesianCategory cat => cat a (Coproduct cat a b)
inr :: CocartesianCategory cat => cat b (Coproduct cat a b)

-- | <tt><a>fanin</a> f g</tt> is written as &lt;math&gt; in category
--   theory literature.
fanin :: CocartesianCategory cat => cat a c -> cat b c -> cat (Coproduct cat a b) c

-- | Bicartesian category is category which is both cartesian and
--   cocartesian.
--   
--   We also require distributive morpism.
class (CartesianCategory cat, CocartesianCategory cat) => BicartesianCategory cat
distr :: BicartesianCategory cat => cat (Product cat (Coproduct cat a b) c) (Coproduct cat (Product cat a c) (Product cat b c))

-- | Closed cartesian category.
class CartesianCategory cat => CCC (cat :: k -> k -> Type) where {
    
    -- | <tt><a>Exponential</a> cat a b</tt> represents &lt;math&gt;. This is
    --   due how (-&gt;) works.
    type family Exponential cat :: k -> k -> k;
}
eval :: CCC cat => cat (Product cat (Exponential cat a b) a) b
transpose :: CCC cat => cat (Product cat a b) c -> cat a (Exponential cat b c)
class Category cat => GeneralizedElement (cat :: k -> k -> Type) where {
    type family Object cat (a :: k) :: Type;
}
konst :: GeneralizedElement cat => Object cat a -> cat x a
newtype WrappedArrow arr a b
WrapArrow :: arr a b -> WrappedArrow arr a b
[unwrapArrow] :: WrappedArrow arr a b -> arr a b
instance forall k (arr :: k -> k -> *). Control.Category.Category arr => Control.Category.Category (Overloaded.Categories.WrappedArrow arr)
instance Control.Arrow.Arrow arr => Overloaded.Categories.CategoryWith1 (Overloaded.Categories.WrappedArrow arr)
instance Control.Arrow.Arrow arr => Overloaded.Categories.CartesianCategory (Overloaded.Categories.WrappedArrow arr)
instance Control.Arrow.ArrowChoice arr => Overloaded.Categories.CategoryWith0 (Overloaded.Categories.WrappedArrow arr)
instance Control.Arrow.ArrowChoice arr => Overloaded.Categories.CocartesianCategory (Overloaded.Categories.WrappedArrow arr)
instance Control.Arrow.ArrowChoice arr => Overloaded.Categories.BicartesianCategory (Overloaded.Categories.WrappedArrow arr)
instance Control.Arrow.ArrowApply arr => Overloaded.Categories.CCC (Overloaded.Categories.WrappedArrow arr)
instance Control.Arrow.Arrow arr => Overloaded.Categories.GeneralizedElement (Overloaded.Categories.WrappedArrow arr)
instance Overloaded.Categories.GeneralizedElement (->)
instance Overloaded.Categories.CCC (->)
instance GHC.Base.Monad m => Overloaded.Categories.CCC (Data.Profunctor.Types.Star m)
instance GHC.Base.Monad m => Overloaded.Categories.CCC (Control.Arrow.Kleisli m)
instance Overloaded.Categories.BicartesianCategory (->)
instance GHC.Base.Monad m => Overloaded.Categories.BicartesianCategory (Data.Profunctor.Types.Star m)
instance GHC.Base.Monad m => Overloaded.Categories.BicartesianCategory (Control.Arrow.Kleisli m)
instance Overloaded.Categories.CategoryWith0 (->)
instance Overloaded.Categories.CategoryWith0 Data.Functor.Contravariant.Op
instance forall k (cat :: k -> k -> *). Overloaded.Categories.CategoryWith1 cat => Overloaded.Categories.CategoryWith0 (Data.Semigroupoid.Dual.Dual cat)
instance forall k (cat :: k -> k -> *). Overloaded.Categories.CategoryWith0 cat => Overloaded.Categories.CategoryWith1 (Data.Semigroupoid.Dual.Dual cat)
instance GHC.Base.Monad m => Overloaded.Categories.CategoryWith0 (Data.Profunctor.Types.Star m)
instance GHC.Base.Monad m => Overloaded.Categories.CategoryWith0 (Control.Arrow.Kleisli m)
instance Overloaded.Categories.CartesianCategory Data.Functor.Contravariant.Op
instance Overloaded.Categories.CocartesianCategory (->)
instance Overloaded.Categories.CocartesianCategory Data.Functor.Contravariant.Op
instance forall k (cat :: k -> k -> *). Overloaded.Categories.CartesianCategory cat => Overloaded.Categories.CocartesianCategory (Data.Semigroupoid.Dual.Dual cat)
instance forall k (cat :: k -> k -> *). Overloaded.Categories.CocartesianCategory cat => Overloaded.Categories.CartesianCategory (Data.Semigroupoid.Dual.Dual cat)
instance GHC.Base.Monad m => Overloaded.Categories.CocartesianCategory (Data.Profunctor.Types.Star m)
instance GHC.Base.Monad m => Overloaded.Categories.CocartesianCategory (Control.Arrow.Kleisli m)
instance Overloaded.Categories.CategoryWith1 (->)
instance Overloaded.Categories.CategoryWith1 Data.Functor.Contravariant.Op
instance GHC.Base.Monad m => Overloaded.Categories.CategoryWith1 (Data.Profunctor.Types.Star m)
instance GHC.Base.Monad m => Overloaded.Categories.CategoryWith1 (Control.Arrow.Kleisli m)
instance Overloaded.Categories.CartesianCategory (->)
instance GHC.Base.Monad m => Overloaded.Categories.CartesianCategory (Data.Profunctor.Types.Star m)
instance GHC.Base.Monad m => Overloaded.Categories.CartesianCategory (Control.Arrow.Kleisli m)


-- | Overloaded characters.
module Overloaded.Chars

-- | Class for <a>Char</a>-like datastructures
--   
--   A character literal <tt><tt>x</tt></tt> is desugared to
--   
--   <pre>
--   <a>fromChar</a> 'x'
--   </pre>
class FromChar a
fromChar :: FromChar a => Char -> a
instance Overloaded.Chars.FromChar GHC.Types.Char

module Overloaded.CodeLabels

-- | Class for auto-spliced labels
--   
--   The labels <tt>#lbl</tt> is desugared into <tt>$$(codeFromlabel
--   @"lbl")</tt> splice.
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:CodeLabels #-}
--   </pre>
--   
--   This feature is not very usable, see
--   <a>https://gitlab.haskell.org/ghc/ghc/-/issues/18211</a>
class IsCodeLabel (sym :: Symbol) a
codeFromLabel :: IsCodeLabel sym a => SpliceQ a

module Overloaded.CodeStrings

-- | Class for auto-spliced string literals
--   
--   The string literals <tt>"beer"</tt> is desugared into
--   <tt>$$(codeFromString @"beer")</tt> splice.
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:CodeLabels #-}
--   </pre>
--   
--   This feature is not very usable, see
--   <a>https://gitlab.haskell.org/ghc/ghc/-/issues/18211</a>
class IsCodeString a
codeFromString :: IsCodeString a => String -> SpliceQ a
instance (a GHC.Types.~ GHC.Types.Char) => Overloaded.CodeStrings.IsCodeString [a]
instance Overloaded.CodeStrings.IsCodeString Data.ByteString.Internal.ByteString


-- | Overloaded "local" <tt>do</tt>-blocks.
--   
--   Inspired by <a>Local Do GHC-proposal</a>. Yet because we do desugaring
--   in reader phase, we must have a bit more complicated setup.
--   
--   The expressions like
--   
--   <pre>
--   ex2d :: IxStateT Identity Int String ()
--   ex2d = ixmonad.do
--       _unused &lt;- ixmodify show
--       ixmodify reverse
--   </pre>
--   
--   are desugared into
--   
--   <pre>
--   ex2b :: IxStateT Identity Int String ()
--   ex2b =
--       ixmonad @Bind (ixmodify show) $ \_unused -&gt;
--       ixmodify reverse
--   </pre>
--   
--   Allowing to locally overload what <tt>do</tt> desugars to.
--   
--   The <a>monad</a> in this module is an example how to define a
--   desugaring. We need to it this way, so the names are easily accessible
--   in renamer phase. (I.e. constant, then transformation is pure, as we
--   don't need to lookup them for each do-block).
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Do #-}
--   </pre>
module Overloaded.Do
data DoMethod

-- | <a>return</a>
Pure :: DoMethod

-- | <a>&gt;&gt;</a>
Then :: DoMethod

-- | <a>&gt;&gt;=</a>
Bind :: DoMethod
type Pure = 'Pure
type Then = 'Then
type Bind = 'Bind
class Monad' (method :: DoMethod) (ty :: Type)
monad :: Monad' method ty => ty
instance (ty GHC.Types.~ (a -> m a), GHC.Base.Applicative m) => Overloaded.Do.Monad' 'Overloaded.Do.Pure ty
instance (ty GHC.Types.~ (m a -> m b -> m b), GHC.Base.Applicative m) => Overloaded.Do.Monad' 'Overloaded.Do.Then ty
instance (ty GHC.Types.~ (m a -> (a -> m b) -> m b), GHC.Base.Monad m) => Overloaded.Do.Monad' 'Overloaded.Do.Bind ty


-- | Overloaded <tt>if</tt>-expression.
module Overloaded.If

-- | Class for <a>Bool</a>-like datastrucutres
--   
--   An <tt>if-</tt>-expression <tt>if b then t else e</tt> is desugared to
--   
--   <pre>
--   ifte (<a>toBool</a> b) t e
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:If #-}
--   </pre>
class ToBool b
toBool :: ToBool b => b -> Bool

-- | <a>ToBool</a> overloaded <tt>if</tt>-expression.
ifte :: ToBool b => b -> a -> a -> a
instance Overloaded.If.ToBool GHC.Types.Bool
instance Overloaded.If.ToBool (GHC.Maybe.Maybe a)
instance Overloaded.If.ToBool (Data.Either.Either b a)


-- | Another way to desugar overloaded list literals. See <a>Nil</a> and
--   <a>Cons</a>.
--   
--   An explicit list expression, e.g. <tt>[1, True]</tt> is desugared to
--   
--   <pre>
--   cons 1 (cons True nil)
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Lists #-}
--   </pre>
module Overloaded.Lists

-- | Class for nil, <tt>[]</tt>
--   
--   See test-suite for ways to define instances for <a>Map</a>. There are
--   at-least two-ways.
class Nil a
nil :: Nil a => a

-- | Class for Cons <tt>:</tt>.
class Cons x ys zs | zs -> x ys
cons :: Cons x ys zs => x -> ys -> zs
infixr 5 `cons`

fromList :: (Nil xs, Cons x xs xs) => [x] -> xs
instance (a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Cons a [b] [c]
instance (a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Cons a [b] (GHC.Base.NonEmpty c)
instance (GHC.Classes.Ord a, a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Cons a (Data.Set.Internal.Set b) (Data.Set.Internal.Set c)
instance Overloaded.Lists.Cons GHC.Types.Int Data.IntSet.Internal.IntSet Data.IntSet.Internal.IntSet
instance (a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Cons a (Data.Sequence.Internal.Seq b) (Data.Sequence.Internal.Seq c)
instance (GHC.Classes.Ord k, k GHC.Types.~ k1, k GHC.Types.~ k2, v GHC.Types.~ v1, v GHC.Types.~ v2) => Overloaded.Lists.Cons (k, v) (Data.Map.Internal.Map k1 v1) (Data.Map.Internal.Map k2 v2)
instance (i GHC.Types.~ GHC.Types.Int, a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Cons (i, a) (Data.IntMap.Internal.IntMap b) (Data.IntMap.Internal.IntMap c)
instance (a GHC.Types.~ b, b GHC.Types.~ c, m GHC.Types.~ 'Data.Nat.S n) => Overloaded.Lists.Cons a (Data.Vec.Lazy.Vec n b) (Data.Vec.Lazy.Vec m c)
instance forall k (f :: k -> *) (g :: k -> *) (h :: k -> *) (xxs :: [k]) (x :: k) (xs :: [k]). (f GHC.Types.~ g, g GHC.Types.~ h, xxs GHC.Types.~ (x : xs)) => Overloaded.Lists.Cons (f x) (Data.SOP.NP.NP g xs) (Data.SOP.NP.NP h xxs)
instance forall k (f :: k -> *) (g :: k -> *) (h :: k -> *) (xsxss :: [[k]]) (xs :: [k]) (xss :: [[k]]). (f GHC.Types.~ g, g GHC.Types.~ h, xsxss GHC.Types.~ (xs : xss)) => Overloaded.Lists.Cons (Data.SOP.NP.NP f xs) (Data.SOP.NP.POP g xss) (Data.SOP.NP.POP h xsxss)
instance (a GHC.Types.~ b, a GHC.Types.~ c) => Overloaded.Lists.Cons a (Data.RAList.Internal.RAList b) (Data.RAList.Internal.RAList c)
instance (a GHC.Types.~ b, a GHC.Types.~ c) => Overloaded.Lists.Cons a (Data.RAList.Internal.RAList b) (Data.RAList.NonEmpty.Internal.NERAList c)
instance (b GHC.Types.~ 'Data.Bin.BP bb, bp GHC.Types.~ Data.Type.Bin.Pred bb, bb GHC.Types.~ Data.Type.Bin.Succ' bp) => Overloaded.Lists.Cons a (Data.RAVec.RAVec bp a) (Data.RAVec.RAVec b a)
instance (bp GHC.Types.~ Data.Type.Bin.Pred b, b GHC.Types.~ Data.Type.Bin.Succ' bp) => Overloaded.Lists.Cons a (Data.RAVec.RAVec bp a) (Data.RAVec.NonEmpty.NERAVec b a)
instance Overloaded.Lists.Nil [a]
instance Overloaded.Lists.Nil (Data.Set.Internal.Set a)
instance Overloaded.Lists.Nil Data.IntSet.Internal.IntSet
instance Overloaded.Lists.Nil (Data.Sequence.Internal.Seq a)
instance Overloaded.Lists.Nil (Data.Map.Internal.Map k v)
instance Overloaded.Lists.Nil (Data.IntMap.Internal.IntMap v)
instance (n GHC.Types.~ 'Data.Nat.Z) => Overloaded.Lists.Nil (Data.Vec.Lazy.Vec n a)
instance forall k (xs :: [k]) (f :: k -> *). (xs GHC.Types.~ '[]) => Overloaded.Lists.Nil (Data.SOP.NP.NP f xs)
instance forall k (xs :: [[k]]) (f :: k -> *). (xs GHC.Types.~ '[]) => Overloaded.Lists.Nil (Data.SOP.NP.POP f xs)
instance Overloaded.Lists.Nil (Data.RAList.Internal.RAList a)
instance (b GHC.Types.~ 'Data.Bin.BZ) => Overloaded.Lists.Nil (Data.RAVec.RAVec b a)


-- | Another way to desugar list literals.
--   
--   An explicit list expression, e.g. <tt>[1, True]</tt> is desugared to
--   
--   <pre>
--   cons 1 (cons True nil)
--   </pre>
--   
--   This desugaring uses bidirectional functional dependencies to make
--   <a>cons</a> infer more. The trade-off is that we can have strictly
--   less instances.
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS_GHC -fplugin=Overloaded
--                   -fplugin-opt=Overloaded:Lists=Overloaded.Lists.Bidi.nil=Overloaded.Lists.Bidi.cons
--   </pre>
module Overloaded.Lists.Bidi
nil :: Nil a => a

-- | Bidirectional class for Cons <tt>:</tt>.
class Cons x ys zs => Cons x ys zs | zs -> x ys, x ys -> zs
cons :: Cons x ys zs => x -> ys -> zs
infixr 5 `cons`

fromList :: (Nil xs, Cons x xs xs) => [x] -> xs
instance (a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Bidi.Cons a [b] [c]
instance (GHC.Classes.Ord a, a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Bidi.Cons a (Data.Set.Internal.Set a) (Data.Set.Internal.Set a)
instance Overloaded.Lists.Bidi.Cons GHC.Types.Int Data.IntSet.Internal.IntSet Data.IntSet.Internal.IntSet
instance (a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Bidi.Cons a (Data.Sequence.Internal.Seq b) (Data.Sequence.Internal.Seq c)
instance (GHC.Classes.Ord k, k GHC.Types.~ k1, k GHC.Types.~ k2, v GHC.Types.~ v1, v GHC.Types.~ v2) => Overloaded.Lists.Bidi.Cons (k, v) (Data.Map.Internal.Map k1 v1) (Data.Map.Internal.Map k2 v2)
instance (i GHC.Types.~ GHC.Types.Int, a GHC.Types.~ b, b GHC.Types.~ c) => Overloaded.Lists.Bidi.Cons (i, a) (Data.IntMap.Internal.IntMap b) (Data.IntMap.Internal.IntMap c)
instance (a GHC.Types.~ b, b GHC.Types.~ c, m GHC.Types.~ 'Data.Nat.S n) => Overloaded.Lists.Bidi.Cons a (Data.Vec.Lazy.Vec n b) (Data.Vec.Lazy.Vec m c)
instance forall k (f :: k -> *) (g :: k -> *) (h :: k -> *) (xxs :: [k]) (x :: k) (xs :: [k]). (f GHC.Types.~ g, g GHC.Types.~ h, xxs GHC.Types.~ (x : xs)) => Overloaded.Lists.Bidi.Cons (f x) (Data.SOP.NP.NP g xs) (Data.SOP.NP.NP h xxs)
instance forall k (f :: k -> *) (g :: k -> *) (h :: k -> *) (xsxss :: [[k]]) (xs :: [k]) (xss :: [[k]]). (f GHC.Types.~ g, g GHC.Types.~ h, xsxss GHC.Types.~ (xs : xss)) => Overloaded.Lists.Bidi.Cons (Data.SOP.NP.NP f xs) (Data.SOP.NP.POP g xss) (Data.SOP.NP.POP h xsxss)


-- | Overloaded natural numbers.
module Overloaded.Naturals

-- | Class for <a>Natural</a>-like datastructures
--   
--   A numeric literal <tt>42</tt> is desugared to
--   
--   <pre>
--   <a>fromNatural</a> 42
--   </pre>
class FromNatural a
fromNatural :: FromNatural a => Natural -> a
instance Overloaded.Naturals.FromNatural GHC.Natural.Natural
instance Overloaded.Naturals.FromNatural GHC.Integer.Type.Integer


-- | Another way to desugar overloaded numeric literals. See
--   <a>FromNumeral</a>.
module Overloaded.Numerals

-- | Another way to desugar numerals.
--   
--   A numeric literal <tt>123</tt> is desugared to
--   
--   <pre>
--   <a>fromNumeral</a> @123
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Numerals #-}
--   </pre>
--   
--   One can do type-level computations with this.
class FromNumeral (n :: Nat) a
fromNumeral :: FromNumeral n a => a

-- | Default implementation of <a>fromNumeral</a>.
--   
--   Usage example:
--   
--   <pre>
--   instance (<a>KnownNat</a> n, ...) =&gt; <a>FromNumeral</a> n MyType where
--       <a>fromNumeral</a> = <a>defaultFromNumeral</a> @n
--   </pre>
defaultFromNumeral :: forall n a. (KnownNat n, Integral a) => a
instance Data.Type.BinP.SBinPI b => Overloaded.Numerals.PosFromNumeral 'Data.Nat.Z b
instance (Data.Type.BinP.SBinPI bp, Overloaded.Numerals.PosFromNumeral n bp, Data.Type.Bin.Pred b GHC.Types.~ 'Data.Bin.BP bp, Data.Type.BinP.Succ bp GHC.Types.~ b) => Overloaded.Numerals.PosFromNumeral ('Data.Nat.S n) b
instance (Overloaded.Numerals.PosFromNumeral (Data.Type.Nat.FromGHC n) b, Overloaded.Numerals.IsLess n (Data.Type.BinP.ToGHC b)) => Overloaded.Numerals.FromNumeral n (Data.BinP.PosP.PosP b)
instance (Overloaded.Numerals.PosFromNumeral (Data.Type.Nat.FromGHC n) b, Overloaded.Numerals.IsLess n (Data.Type.BinP.ToGHC b)) => Overloaded.Numerals.FromNumeral n (Data.Bin.Pos.Pos ('Data.Bin.BP b))
instance Overloaded.Numerals.FinFromNumeral 'Data.Nat.Z ('Data.Nat.S m)
instance Overloaded.Numerals.FinFromNumeral n m => Overloaded.Numerals.FinFromNumeral ('Data.Nat.S n) ('Data.Nat.S m)
instance (Overloaded.Numerals.FinFromNumeral (Data.Type.Nat.FromGHC n) m, Overloaded.Numerals.IsLess n (Data.Type.Nat.ToGHC m)) => Overloaded.Numerals.FromNumeral n (Data.Fin.Fin m)
instance (GHC.TypeNats.KnownNat n, Overloaded.Numerals.OverflowCheck n "Word8" (n GHC.TypeNats.<=? 255)) => Overloaded.Numerals.FromNumeral n GHC.Word.Word8
instance (GHC.TypeNats.KnownNat n, Overloaded.Numerals.OverflowCheck n "Word8" (n GHC.TypeNats.<=? 65535)) => Overloaded.Numerals.FromNumeral n GHC.Word.Word16
instance (GHC.TypeNats.KnownNat n, Overloaded.Numerals.OverflowCheck n "Word8" (n GHC.TypeNats.<=? 4294967295)) => Overloaded.Numerals.FromNumeral n GHC.Word.Word32
instance (GHC.TypeNats.KnownNat n, Overloaded.Numerals.OverflowCheck n "Word8" (n GHC.TypeNats.<=? 18446744073709551615)) => Overloaded.Numerals.FromNumeral n GHC.Word.Word64
instance GHC.TypeNats.KnownNat n => Overloaded.Numerals.FromNumeral n GHC.Natural.Natural
instance GHC.TypeNats.KnownNat n => Overloaded.Numerals.FromNumeral n GHC.Integer.Type.Integer
instance GHC.TypeNats.KnownNat n => Overloaded.Numerals.FromNumeral n GHC.Types.Int
instance GHC.TypeNats.KnownNat n => Overloaded.Numerals.FromNumeral n Data.Nat.Nat
instance GHC.TypeNats.KnownNat n => Overloaded.Numerals.FromNumeral n Data.Bin.Bin
instance (GHC.TypeNats.KnownNat n, (1 GHC.TypeNats.<=? n) GHC.Types.~ 'GHC.Types.True) => Overloaded.Numerals.FromNumeral n Data.BinP.BinP


-- | Overloaded plugin, which makes magic possible.
module Overloaded.Plugin

-- | <tt>Overloaded</tt> plugin.
--   
--   To enable plugin put the following at top of the module:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols #-}
--   </pre>
--   
--   At least one option is required, multiple can given either using
--   multiple <tt>-fplugin-opt</tt> options, or by separating options with
--   colon:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols:Numerals #-}
--   </pre>
--   
--   Options also take optional desugaring names, for example
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Labels=Data.Generics.ProductFields.field #-}
--   </pre>
--   
--   to desugar <tt>OverloadedLabels</tt> directly into <tt>field</tt> from
--   <tt>generics-lens</tt> (no need to import orphan instance!)
--   
--   <h2>Supported options</h2>
--   
--   <ul>
--   <li><tt>Symbols</tt> desugars literal strings to <tt><a>fromSymbol</a>
--   @sym</tt></li>
--   <li><tt>Strings</tt> works like built-in <tt>OverloadedStrings</tt>
--   (but you can use different method than <a>fromString</a>)</li>
--   <li><tt>Numerals</tt> desugars literal numbers to
--   <tt><a>fromNumeral</a> @nat</tt></li>
--   <li><tt>Naturals</tt> desugars literal numbers to
--   <tt><a>fromNatural</a> nat</tt> (i.e. like <a>fromString</a>)</li>
--   <li><tt>Chars</tt> desugars literal characters to <tt><a>fromChars</a>
--   c</tt>. <i>Note:</i> there isn't type-level alternative: we cannot
--   promote <a>Char</a>s</li>
--   <li><tt>Lists</tt> <b>is not</b> like built-in
--   <tt>OverloadedLists</tt>, but desugars explicit lists to <a>cons</a>
--   and <a>nil</a></li>
--   <li><tt>If</tt> desugars <tt>if</tt>-expressions to <tt><a>ifte</a> b
--   t e</tt></li>
--   <li><tt>Unit</tt> desugars <tt>()</tt>-expressions to
--   <tt><a>nil</a></tt> (but you can use different method, e.g.
--   <tt>boring</tt> from <a>Data.Boring</a>)</li>
--   <li><tt>Labels</tt> works like built-in <tt>OverloadedLabels</tt> (you
--   should enable <tt>OverloadedLabels</tt> so parser recognises the
--   syntax)</li>
--   <li><tt>TypeNats</tt> and <tt>TypeSymbols</tt> desugar type-level
--   literals into <tt><a>FromNat</a></tt> and
--   <tt><a>FromTypeSymbol</a></tt> respectively</li>
--   <li><tt>Do</tt> desugar in <i>Local Do</i> fashion. See examples.</li>
--   <li><tt>Categories</tt> change <tt>Arrows</tt> desugaring to use
--   <i>"correct"</i> category classes.</li>
--   <li><tt>CodeLabels</tt> desugars <tt>OverloadedLabels</tt> into Typed
--   Template Haskell splices</li>
--   <li><tt>CodeStrings</tt> desugars string literals into Typed Template
--   Haskell splices</li>
--   <li><tt>RebindableApplication</tt> changes how juxtaposition is
--   interpreted</li>
--   </ul>
--   
--   <h2>Known limitations</h2>
--   
--   <ul>
--   <li>Doesn't desugar inside patterns</li>
--   </ul>
--   
--   <h2>RecordFields</h2>
--   
--   <b>WARNING</b> the type-checker plugin is experimental, it's adviced
--   to use
--   
--   <pre>
--   {-# OPTIONS_GHC -ddump-simpl #-}
--   </pre>
--   
--   to avoid surprising segfaults.
--   
--   <h3>Usage</h3>
--   
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:RecordFields
--   #-}
--   
--   <h3>Implementation bits</h3>
--   
--   See Note [HasField instances] in <a>ClsInst</a>, the behavior of this
--   plugin is similar.
--   
--   The <a>HasField</a> class is defined in <a>GHC.Records.Compat</a>
--   module of <tt>record-hasfield</tt> package:
--   
--   <pre>
--   class <a>HasField</a> {k} x r a | x r -&gt; a where
--       <a>hasField</a> :: r -&gt; (a -&gt; r, a)
--   </pre>
--   
--   Suppose we have
--   
--   <pre>
--   data R y = MkR { foo :: [y] }
--   </pre>
--   
--   and <tt>foo</tt> in scope. We will solve constraints like
--   
--   <pre>
--   HasField "foo" (R Int) a
--   </pre>
--   
--   by emitting a new wanted constraint
--   
--   <pre>
--   [Int] ~# a
--   </pre>
--   
--   and building a <tt>HasField</tt> dictionary out of selector
--   <tt>foo</tt> appropriately cast.
--   
--   <h2>Idiom brackets from TemplateHaskellQuotes</h2>
--   
--   <pre>
--   {-# LANGUAGE TemplateHaskellQuotes #-}
--   {-# OPTIONS_GHC -fplugin=Overloaded -fplugin-opt=Overloaded:IdiomBrackets #-}
--   
--   data Tree a
--       = Leaf a
--       | Branch (Tree a) (Tree a)
--     deriving (Show)
--   
--   instance Functor Tree where
--       <a>fmap</a> f (Leaf x)     = Leaf (f x)
--       <a>fmap</a> f (Branch l r) = Branch (<a>fmap</a> f l) (<a>fmap</a> f r)
--   
--   instance Traversable Tree where
--       <a>traverse</a> f (Leaf x)     = [| Leaf (f x) |]
--       <a>traverse</a> f (Branch l r) = [| Branch (<a>traverse</a> f l) (<a>traverse</a> f r) |]
--   </pre>
--   
--   <h2>RebindableApplication</h2>
--   
--   Converts all <tt>f x</tt> applications into <tt>(f $ x)</tt> with
--   whatever <tt>$</tt> is in scope.
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:RebindableApplication #-}
--   
--   let f = pure ((+) :: Int -&gt; Int -&gt; Int)
--       x = Just 1
--       y = Just 2
--   
--       z = let ($) = (<a>&lt;*&gt;</a>) in f x y
--   in z
--   </pre>
plugin :: Plugin
instance GHC.Show.Show Overloaded.Plugin.StrSym
instance GHC.Classes.Eq Overloaded.Plugin.StrSym
instance GHC.Show.Show Overloaded.Plugin.NumNat
instance GHC.Classes.Eq Overloaded.Plugin.NumNat
instance GHC.Show.Show Overloaded.Plugin.LabelOpt
instance GHC.Classes.Eq Overloaded.Plugin.LabelOpt
instance GHC.Show.Show a => GHC.Show.Show (Overloaded.Plugin.OnOff a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Overloaded.Plugin.OnOff a)
instance GHC.Show.Show Overloaded.Plugin.Options
instance GHC.Classes.Eq Overloaded.Plugin.Options


-- | Another way to desugar overloaded string literals. See
--   <a>FromSymbol</a>.
module Overloaded.Symbols

-- | Another way to desugar overloaded string literals using this class.
--   
--   A string literal <tt>"example"</tt> is desugared to
--   
--   <pre>
--   <a>fromSymbol</a> @"example"
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols #-}
--   </pre>
class FromSymbol (s :: Symbol) a
fromSymbol :: FromSymbol s a => a
instance (GHC.TypeNats.KnownNat y, GHC.TypeNats.KnownNat m, GHC.TypeNats.KnownNat d, Overloaded.Symbols.ParseDay s GHC.Types.~ '(y, m, d)) => Overloaded.Symbols.FromSymbol s Data.Time.Calendar.Days.Day
instance (GHC.TypeLits.KnownSymbol s, Overloaded.Symbols.SeqList (Data.Symbol.Ascii.Internal.ToList s)) => Overloaded.Symbols.FromSymbol s Data.ByteString.Internal.ByteString
instance (GHC.TypeLits.KnownSymbol s, Overloaded.Symbols.SeqList (Data.Symbol.Ascii.Internal.ToList s)) => Overloaded.Symbols.FromSymbol s Data.ByteString.Lazy.Internal.ByteString
instance (GHC.TypeLits.KnownSymbol s, a GHC.Types.~ GHC.Types.Char) => Overloaded.Symbols.FromSymbol s [a]
instance GHC.TypeLits.KnownSymbol s => Overloaded.Symbols.FromSymbol s Data.Text.Internal.Text
instance GHC.TypeLits.KnownSymbol s => Overloaded.Symbols.FromSymbol s Data.Text.Internal.Lazy.Text


-- | Overloaded type-level natural numbers.
module Overloaded.TypeNats

-- | A way to overload type level <a>Nat</a>s.
--   
--   A number type-literal <tt>42</tt> is desugared to
--   
--   <pre>
--   <a>FromNat</a> 42
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:TypeNats #-}
--   </pre>
class FromNatC a where {
    type family FromNat (n :: Nat) :: a;
}
instance Overloaded.TypeNats.FromNatC GHC.Types.Nat
instance Overloaded.TypeNats.FromNatC Data.Nat.Nat
instance Overloaded.TypeNats.FromNatC Data.Bin.Bin
instance Overloaded.TypeNats.FromNatC Data.BinP.BinP


-- | Overloaded type-level symbols.
module Overloaded.TypeSymbols

-- | A way to overload type level <a>Symbol</a>s.
--   
--   A symbol type-literal <tt>"example"</tt> is desugared to
--   
--   <pre>
--   <a>FromTypeSymbol</a> "example"
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:TypeSymbols #-}
--   </pre>
class FromTypeSymbolC a where {
    type family FromTypeSymbol (s :: Symbol) :: a;
}
instance Overloaded.TypeSymbols.FromTypeSymbolC GHC.Types.Symbol


-- | <tt>Overloaded*</tt> language extensions as a source plugin.
module Overloaded

-- | <tt>Overloaded</tt> plugin.
--   
--   To enable plugin put the following at top of the module:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols #-}
--   </pre>
--   
--   At least one option is required, multiple can given either using
--   multiple <tt>-fplugin-opt</tt> options, or by separating options with
--   colon:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols:Numerals #-}
--   </pre>
--   
--   Options also take optional desugaring names, for example
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Labels=Data.Generics.ProductFields.field #-}
--   </pre>
--   
--   to desugar <tt>OverloadedLabels</tt> directly into <tt>field</tt> from
--   <tt>generics-lens</tt> (no need to import orphan instance!)
--   
--   <h2>Supported options</h2>
--   
--   <ul>
--   <li><tt>Symbols</tt> desugars literal strings to <tt><a>fromSymbol</a>
--   @sym</tt></li>
--   <li><tt>Strings</tt> works like built-in <tt>OverloadedStrings</tt>
--   (but you can use different method than <a>fromString</a>)</li>
--   <li><tt>Numerals</tt> desugars literal numbers to
--   <tt><a>fromNumeral</a> @nat</tt></li>
--   <li><tt>Naturals</tt> desugars literal numbers to
--   <tt><a>fromNatural</a> nat</tt> (i.e. like <a>fromString</a>)</li>
--   <li><tt>Chars</tt> desugars literal characters to <tt><a>fromChars</a>
--   c</tt>. <i>Note:</i> there isn't type-level alternative: we cannot
--   promote <a>Char</a>s</li>
--   <li><tt>Lists</tt> <b>is not</b> like built-in
--   <tt>OverloadedLists</tt>, but desugars explicit lists to <a>cons</a>
--   and <a>nil</a></li>
--   <li><tt>If</tt> desugars <tt>if</tt>-expressions to <tt><a>ifte</a> b
--   t e</tt></li>
--   <li><tt>Unit</tt> desugars <tt>()</tt>-expressions to
--   <tt><a>nil</a></tt> (but you can use different method, e.g.
--   <tt>boring</tt> from <a>Data.Boring</a>)</li>
--   <li><tt>Labels</tt> works like built-in <tt>OverloadedLabels</tt> (you
--   should enable <tt>OverloadedLabels</tt> so parser recognises the
--   syntax)</li>
--   <li><tt>TypeNats</tt> and <tt>TypeSymbols</tt> desugar type-level
--   literals into <tt><a>FromNat</a></tt> and
--   <tt><a>FromTypeSymbol</a></tt> respectively</li>
--   <li><tt>Do</tt> desugar in <i>Local Do</i> fashion. See examples.</li>
--   <li><tt>Categories</tt> change <tt>Arrows</tt> desugaring to use
--   <i>"correct"</i> category classes.</li>
--   <li><tt>CodeLabels</tt> desugars <tt>OverloadedLabels</tt> into Typed
--   Template Haskell splices</li>
--   <li><tt>CodeStrings</tt> desugars string literals into Typed Template
--   Haskell splices</li>
--   <li><tt>RebindableApplication</tt> changes how juxtaposition is
--   interpreted</li>
--   </ul>
--   
--   <h2>Known limitations</h2>
--   
--   <ul>
--   <li>Doesn't desugar inside patterns</li>
--   </ul>
--   
--   <h2>RecordFields</h2>
--   
--   <b>WARNING</b> the type-checker plugin is experimental, it's adviced
--   to use
--   
--   <pre>
--   {-# OPTIONS_GHC -ddump-simpl #-}
--   </pre>
--   
--   to avoid surprising segfaults.
--   
--   <h3>Usage</h3>
--   
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:RecordFields
--   #-}
--   
--   <h3>Implementation bits</h3>
--   
--   See Note [HasField instances] in <a>ClsInst</a>, the behavior of this
--   plugin is similar.
--   
--   The <a>HasField</a> class is defined in <a>GHC.Records.Compat</a>
--   module of <tt>record-hasfield</tt> package:
--   
--   <pre>
--   class <a>HasField</a> {k} x r a | x r -&gt; a where
--       <a>hasField</a> :: r -&gt; (a -&gt; r, a)
--   </pre>
--   
--   Suppose we have
--   
--   <pre>
--   data R y = MkR { foo :: [y] }
--   </pre>
--   
--   and <tt>foo</tt> in scope. We will solve constraints like
--   
--   <pre>
--   HasField "foo" (R Int) a
--   </pre>
--   
--   by emitting a new wanted constraint
--   
--   <pre>
--   [Int] ~# a
--   </pre>
--   
--   and building a <tt>HasField</tt> dictionary out of selector
--   <tt>foo</tt> appropriately cast.
--   
--   <h2>Idiom brackets from TemplateHaskellQuotes</h2>
--   
--   <pre>
--   {-# LANGUAGE TemplateHaskellQuotes #-}
--   {-# OPTIONS_GHC -fplugin=Overloaded -fplugin-opt=Overloaded:IdiomBrackets #-}
--   
--   data Tree a
--       = Leaf a
--       | Branch (Tree a) (Tree a)
--     deriving (Show)
--   
--   instance Functor Tree where
--       <a>fmap</a> f (Leaf x)     = Leaf (f x)
--       <a>fmap</a> f (Branch l r) = Branch (<a>fmap</a> f l) (<a>fmap</a> f r)
--   
--   instance Traversable Tree where
--       <a>traverse</a> f (Leaf x)     = [| Leaf (f x) |]
--       <a>traverse</a> f (Branch l r) = [| Branch (<a>traverse</a> f l) (<a>traverse</a> f r) |]
--   </pre>
--   
--   <h2>RebindableApplication</h2>
--   
--   Converts all <tt>f x</tt> applications into <tt>(f $ x)</tt> with
--   whatever <tt>$</tt> is in scope.
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:RebindableApplication #-}
--   
--   let f = pure ((+) :: Int -&gt; Int -&gt; Int)
--       x = Just 1
--       y = Just 2
--   
--       z = let ($) = (<a>&lt;*&gt;</a>) in f x y
--   in z
--   </pre>
plugin :: Plugin

-- | Another way to desugar overloaded string literals using this class.
--   
--   A string literal <tt>"example"</tt> is desugared to
--   
--   <pre>
--   <a>fromSymbol</a> @"example"
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Symbols #-}
--   </pre>
class FromSymbol (s :: Symbol) a
fromSymbol :: FromSymbol s a => a

-- | Another way to desugar numerals.
--   
--   A numeric literal <tt>123</tt> is desugared to
--   
--   <pre>
--   <a>fromNumeral</a> @123
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:Numerals #-}
--   </pre>
--   
--   One can do type-level computations with this.
class FromNumeral (n :: Nat) a
fromNumeral :: FromNumeral n a => a

-- | Default implementation of <a>fromNumeral</a>.
--   
--   Usage example:
--   
--   <pre>
--   instance (<a>KnownNat</a> n, ...) =&gt; <a>FromNumeral</a> n MyType where
--       <a>fromNumeral</a> = <a>defaultFromNumeral</a> @n
--   </pre>
defaultFromNumeral :: forall n a. (KnownNat n, Integral a) => a

-- | Class for <a>Natural</a>-like datastructures
--   
--   A numeric literal <tt>42</tt> is desugared to
--   
--   <pre>
--   <a>fromNatural</a> 42
--   </pre>
class FromNatural a
fromNatural :: FromNatural a => Natural -> a

-- | Class for <a>Char</a>-like datastructures
--   
--   A character literal <tt><tt>x</tt></tt> is desugared to
--   
--   <pre>
--   <a>fromChar</a> 'x'
--   </pre>
class FromChar a
fromChar :: FromChar a => Char -> a

-- | Class for nil, <tt>[]</tt>
--   
--   See test-suite for ways to define instances for <a>Map</a>. There are
--   at-least two-ways.
class Nil a
nil :: Nil a => a

-- | Class for Cons <tt>:</tt>.
class Cons x ys zs | zs -> x ys
cons :: Cons x ys zs => x -> ys -> zs
infixr 5 `cons`

-- | Class for <a>Bool</a>-like datastrucutres
--   
--   An <tt>if-</tt>-expression <tt>if b then t else e</tt> is desugared to
--   
--   <pre>
--   ifte (<a>toBool</a> b) t e
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:If #-}
--   </pre>
class ToBool b
toBool :: ToBool b => b -> Bool

-- | <a>ToBool</a> overloaded <tt>if</tt>-expression.
ifte :: ToBool b => b -> a -> a -> a

-- | Class for auto-spliced labels
--   
--   The labels <tt>#lbl</tt> is desugared into <tt>$$(codeFromlabel
--   @"lbl")</tt> splice.
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:CodeLabels #-}
--   </pre>
--   
--   This feature is not very usable, see
--   <a>https://gitlab.haskell.org/ghc/ghc/-/issues/18211</a>
class IsCodeLabel (sym :: Symbol) a
codeFromLabel :: IsCodeLabel sym a => SpliceQ a

-- | Class for auto-spliced string literals
--   
--   The string literals <tt>"beer"</tt> is desugared into
--   <tt>$$(codeFromString @"beer")</tt> splice.
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:CodeLabels #-}
--   </pre>
--   
--   This feature is not very usable, see
--   <a>https://gitlab.haskell.org/ghc/ghc/-/issues/18211</a>
class IsCodeString a
codeFromString :: IsCodeString a => String -> SpliceQ a

-- | A way to overload type level <a>Nat</a>s.
--   
--   A number type-literal <tt>42</tt> is desugared to
--   
--   <pre>
--   <a>FromNat</a> 42
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:TypeNats #-}
--   </pre>
class FromNatC a where {
    type family FromNat (n :: Nat) :: a;
}

-- | A way to overload type level <a>Symbol</a>s.
--   
--   A symbol type-literal <tt>"example"</tt> is desugared to
--   
--   <pre>
--   <a>FromTypeSymbol</a> "example"
--   </pre>
--   
--   Enabled with:
--   
--   <pre>
--   {-# OPTIONS -fplugin=Overloaded -fplugin-opt=Overloaded:TypeSymbols #-}
--   </pre>
class FromTypeSymbolC a where {
    type family FromTypeSymbol (s :: Symbol) :: a;
}
data DoMethod

-- | <a>return</a>
Pure :: DoMethod

-- | <a>&gt;&gt;</a>
Then :: DoMethod

-- | <a>&gt;&gt;=</a>
Bind :: DoMethod
type Pure = 'Pure
type Then = 'Then
type Bind = 'Bind
class Monad' (method :: DoMethod) (ty :: Type)
monad :: Monad' method ty => ty

-- | A class for categories. Instances should satisfy the laws
--   
--   <ul>
--   <li><i>Right identity</i> <tt>f <a>.</a> <a>id</a> = f</tt></li>
--   <li><i>Left identity</i> <tt><a>id</a> <a>.</a> f = f</tt></li>
--   <li><i>Associativity</i> <tt>f <a>.</a> (g <a>.</a> h) = (f <a>.</a>
--   g) <a>.</a> h</tt></li>
--   </ul>
class Category (cat :: k -> k -> Type)

-- | A non-clashing name for <a>id</a>.
identity :: Category cat => cat a a

-- | A non-clashing name for <tt>(<a>.</a>)</tt>.
(%%) :: Category cat => cat b c -> cat a b -> cat a c
infixr 9 %%

-- | Cartesian category is a monoidal category where monoidal product is
--   the categorical product.
class Category cat => CartesianCategory (cat :: k -> k -> Type) where {
    type family Product cat :: k -> k -> k;
}
proj1 :: CartesianCategory cat => cat (Product cat a b) a
proj2 :: CartesianCategory cat => cat (Product cat a b) b

-- | <tt><a>fanout</a> f g</tt> is written as &lt;math&gt; in category
--   theory literature.
fanout :: CartesianCategory cat => cat a b -> cat a c -> cat a (Product cat b c)

-- | Cocartesian category is a monoidal category where monoidal product is
--   the categorical coproduct.
class Category cat => CocartesianCategory (cat :: k -> k -> Type) where {
    type family Coproduct cat :: k -> k -> k;
}
inl :: CocartesianCategory cat => cat a (Coproduct cat a b)
inr :: CocartesianCategory cat => cat b (Coproduct cat a b)

-- | <tt><a>fanin</a> f g</tt> is written as &lt;math&gt; in category
--   theory literature.
fanin :: CocartesianCategory cat => cat a c -> cat b c -> cat (Coproduct cat a b) c

-- | Bicartesian category is category which is both cartesian and
--   cocartesian.
--   
--   We also require distributive morpism.
class (CartesianCategory cat, CocartesianCategory cat) => BicartesianCategory cat
distr :: BicartesianCategory cat => cat (Product cat (Coproduct cat a b) c) (Coproduct cat (Product cat a c) (Product cat b c))

-- | Closed cartesian category.
class CartesianCategory cat => CCC (cat :: k -> k -> Type) where {
    
    -- | <tt><a>Exponential</a> cat a b</tt> represents &lt;math&gt;. This is
    --   due how (-&gt;) works.
    type family Exponential cat :: k -> k -> k;
}
eval :: CCC cat => cat (Product cat (Exponential cat a b) a) b
transpose :: CCC cat => cat (Product cat a b) c -> cat a (Exponential cat b c)