-- 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.2


-- | 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


-- | 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 Data.Type.Equality.~ b, b Data.Type.Equality.~ c) => Overloaded.Lists.Cons a [b] [c]
instance (a Data.Type.Equality.~ b, b Data.Type.Equality.~ c) => Overloaded.Lists.Cons a [b] (GHC.Base.NonEmpty c)
instance (GHC.Classes.Ord a, a Data.Type.Equality.~ b, b Data.Type.Equality.~ 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 Data.Type.Equality.~ b, b Data.Type.Equality.~ c) => Overloaded.Lists.Cons a (Data.Sequence.Internal.Seq b) (Data.Sequence.Internal.Seq c)
instance (GHC.Classes.Ord k, k Data.Type.Equality.~ k1, k Data.Type.Equality.~ k2, v Data.Type.Equality.~ v1, v Data.Type.Equality.~ v2) => Overloaded.Lists.Cons (k, v) (Data.Map.Internal.Map k1 v1) (Data.Map.Internal.Map k2 v2)
instance (i Data.Type.Equality.~ GHC.Types.Int, a Data.Type.Equality.~ b, b Data.Type.Equality.~ c) => Overloaded.Lists.Cons (i, a) (Data.IntMap.Internal.IntMap b) (Data.IntMap.Internal.IntMap c)
instance (a Data.Type.Equality.~ b, b Data.Type.Equality.~ c, m Data.Type.Equality.~ '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 Data.Type.Equality.~ g, g Data.Type.Equality.~ h, xxs Data.Type.Equality.~ (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 Data.Type.Equality.~ g, g Data.Type.Equality.~ h, xsxss Data.Type.Equality.~ (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 Data.Type.Equality.~ b, a Data.Type.Equality.~ c) => Overloaded.Lists.Cons a (Data.RAList.Internal.RAList b) (Data.RAList.Internal.RAList c)
instance (a Data.Type.Equality.~ b, a Data.Type.Equality.~ c) => Overloaded.Lists.Cons a (Data.RAList.Internal.RAList b) (Data.RAList.NonEmpty.Internal.NERAList c)
instance (b Data.Type.Equality.~ 'Data.Bin.BP bb, bp Data.Type.Equality.~ Data.Type.Bin.Pred bb, bb Data.Type.Equality.~ Data.Type.Bin.Succ' bp) => Overloaded.Lists.Cons a (Data.RAVec.RAVec bp a) (Data.RAVec.RAVec b a)
instance (bp Data.Type.Equality.~ Data.Type.Bin.Pred b, b Data.Type.Equality.~ 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 Data.Type.Equality.~ 'Data.Nat.Z) => Overloaded.Lists.Nil (Data.Vec.Lazy.Vec n a)
instance forall k (xs :: [k]) (f :: k -> *). (xs Data.Type.Equality.~ '[]) => Overloaded.Lists.Nil (Data.SOP.NP.NP f xs)
instance forall k (xs :: [[k]]) (f :: k -> *). (xs Data.Type.Equality.~ '[]) => Overloaded.Lists.Nil (Data.SOP.NP.POP f xs)
instance Overloaded.Lists.Nil (Data.RAList.Internal.RAList a)
instance (b Data.Type.Equality.~ '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 Data.Type.Equality.~ b, b Data.Type.Equality.~ c) => Overloaded.Lists.Bidi.Cons a [b] [c]
instance (GHC.Classes.Ord a, a Data.Type.Equality.~ b, b Data.Type.Equality.~ 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 Data.Type.Equality.~ b, b Data.Type.Equality.~ c) => Overloaded.Lists.Bidi.Cons a (Data.Sequence.Internal.Seq b) (Data.Sequence.Internal.Seq c)
instance (GHC.Classes.Ord k, k Data.Type.Equality.~ k1, k Data.Type.Equality.~ k2, v Data.Type.Equality.~ v1, v Data.Type.Equality.~ v2) => Overloaded.Lists.Bidi.Cons (k, v) (Data.Map.Internal.Map k1 v1) (Data.Map.Internal.Map k2 v2)
instance (i Data.Type.Equality.~ GHC.Types.Int, a Data.Type.Equality.~ b, b Data.Type.Equality.~ c) => Overloaded.Lists.Bidi.Cons (i, a) (Data.IntMap.Internal.IntMap b) (Data.IntMap.Internal.IntMap c)
instance (a Data.Type.Equality.~ b, b Data.Type.Equality.~ c, m Data.Type.Equality.~ '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 Data.Type.Equality.~ g, g Data.Type.Equality.~ h, xxs Data.Type.Equality.~ (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 Data.Type.Equality.~ g, g Data.Type.Equality.~ h, xsxss Data.Type.Equality.~ (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 Data.Type.Equality.~ 'Data.Bin.BP bp, Data.Type.BinP.Succ bp Data.Type.Equality.~ 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) Data.Type.Equality.~ '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>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>
--   </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>
plugin :: Plugin
instance GHC.Show.Show a => GHC.Show.Show (Overloaded.Plugin.V4 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Overloaded.Plugin.V4 a)
instance GHC.Show.Show Overloaded.Plugin.Options
instance GHC.Classes.Eq Overloaded.Plugin.Options
instance GHC.Show.Show a => GHC.Show.Show (Overloaded.Plugin.V2 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Overloaded.Plugin.V2 a)
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.VarName
instance GHC.Classes.Eq Overloaded.Plugin.VarName
instance GHC.Show.Show a => GHC.Show.Show (Overloaded.Plugin.OnOff a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Overloaded.Plugin.OnOff a)


-- | 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 Data.Type.Equality.~ '(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 Data.Type.Equality.~ 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>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>
--   </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>
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

-- | 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;
}