    {-# LANGUAGE AllowAmbiguousTypes #-}
    {-# LANGUAGE CPP #-}
    {-# LANGUAGE ConstraintKinds #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DerivingStrategies #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE FunctionalDependencies #-}
    {-# LANGUAGE GADTs #-}
    {-# LANGUAGE PolyKinds #-}
    {-# LANGUAGE QuantifiedConstraints #-}
    {-# LANGUAGE Rank2Types #-}
    {-# LANGUAGE RoleAnnotations #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE StandaloneDeriving #-}
    {-# LANGUAGE Trustworthy #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE TypeOperators #-}
    {-# LANGUAGE UndecidableInstances #-}
    {-# LANGUAGE UndecidableSuperClasses #-}
    {-# LANGUAGE UnicodeSyntax #-}

    -- |
    -- Copyright   :  (C) 2011-2015 Edward Kmett,
    -- License     :  BSD-style (see the file LICENSE)
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  experimental
    -- Portability :  non-portable
    --
    -- @ConstraintKinds@ made type classes into types of a new kind, @Constraint@.
    --
    -- @
    -- 'Eq' :: * -> 'Constraint'
    -- 'Ord' :: * -> 'Constraint'
    -- 'Monad' :: (* -> *) -> 'Constraint'
    -- @
    --
    -- The need for this extension was first publicized in the paper
    --
    -- <https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/gmap3.pdf Scrap your boilerplate with class: extensible generic functions>
    --
    -- by Ralf Lämmel and Simon Peyton Jones in 2005, which shoehorned all the
    -- things they needed into a custom 'Sat' typeclass.
    --
    -- With @ConstraintKinds@ we can put into code a lot of tools for manipulating
    -- these new types without such awkward workarounds.

    module Data.Constraint
      (
      -- * The Kind of Constraints
        Constraint
      -- * Dictionary
      , Dict(Dict)
      , HasDict(..)
      , withDict
      , (\\)
      -- * Entailment
      , (:-)(Sub)
      , type (⊢)
      , type (|-)
      , type (&)
      , weaken1, weaken2, contract
      , strengthen1, strengthen2
      , (&&&), (***)
      , trans, refl
      , implied
      , Bottom(no)
      , top, bottom
      -- * Dict is fully faithful
      , mapDict
      , unmapDict
      -- * Reflection
      , Class(..)
      , (:=>)(..)
      ) where
    import Control.Applicative
    import Control.Category
    import Control.DeepSeq
    import Control.Monad
    import Data.Complex
    import Data.Ratio
    import Data.Data hiding (TypeRep)
    import qualified GHC.Exts as Exts (Any)
    import GHC.Exts (Constraint)
    import Data.Bits (Bits)
    import Data.Functor.Identity (Identity)
    import Numeric.Natural (Natural)
    import Data.Coerce (Coercible)
    import Data.Type.Coercion(Coercion(..))
    import Data.Type.Equality (type (~~))
    import qualified Data.Type.Equality as Hetero
    import Type.Reflection (TypeRep, typeRepKind, withTypeable)
    import Data.Boring (Boring (..))

    -- | Values of type @'Dict' p@ capture a dictionary for a constraint of type @p@.
    --
    -- e.g.
    --
    -- @
    -- 'Dict' :: 'Dict' ('Eq' 'Int')
    -- @
    --
    -- captures a dictionary that proves we have an:
    --
    -- @
    -- instance 'Eq' 'Int'
    -- @
    --
    -- Pattern matching on the 'Dict' constructor will bring this instance into scope.
    --
    data Dict :: Constraint -> * where
      Dict :: a => Dict a
      deriving Typeable

    deriving stock instance (Typeable p, p) => Data (Dict p)
    deriving stock instance Eq (Dict a)
    deriving stock instance Ord (Dict a)
    deriving stock instance Show (Dict a)

    instance c => Boring (Dict c) where
        boring :: Dict c
    boring = Dict c
    forall (c :: Constraint). c => Dict c
    Dict

    {-
    instance (Typeable p, p) => Data (Dict p) where
      gfoldl _ z Dict = z Dict
      toConstr _ = dictConstr
      gunfold _ z c = case constrIndex c of
        1 -> z Dict
        _ -> error "gunfold"
      dataTypeOf _ = dictDataType

    dictConstr :: Constr
    dictConstr = mkConstr dictDataType "Dict" [] Prefix

    dictDataType :: DataType
    dictDataType = mkDataType "Data.Constraint.Dict" [dictConstr]
    -}

    instance NFData (Dict c) where
      rnf :: Dict c -> ()
    rnf Dict c
    Dict = ()

    -- | Witnesses that a value of type @e@ contains evidence of the constraint @c@.
    --
    -- Mainly intended to allow ('\\') to be overloaded, since it's a useful operator.
    class HasDict c e | e -> c where
      evidence :: e -> Dict c

    instance HasDict a (Dict a) where
      evidence :: Dict a -> Dict a
    evidence = Dict a -> Dict a
    forall a. a -> a
    Prelude.id

    instance a => HasDict b (a :- b) where
      evidence :: (a :- b) -> Dict b
    evidence (Sub a => Dict b
    x) = Dict b
    a => Dict b
    x

    instance HasDict (Coercible a b) (Coercion a b) where
      evidence :: Coercion a b -> Dict (Coercible a b)
    evidence Coercion a b
    Coercion = Dict (Coercible a b)
    forall (c :: Constraint). c => Dict c
    Dict

    instance HasDict (a ~ b) (a :~: b) where
      evidence :: (a :~: b) -> Dict (a ~ b)
    evidence a :~: b
    Refl = Dict (a ~ b)
    forall (c :: Constraint). c => Dict c
    Dict

    instance HasDict (a ~~ b) (a Hetero.:~~: b) where
      evidence :: (a :~~: b) -> Dict (a ~~ b)
    evidence a :~~: b
    Hetero.HRefl = Dict (a ~~ b)
    forall (c :: Constraint). c => Dict c
    Dict

    instance HasDict (Typeable k, Typeable a) (TypeRep (a :: k)) where
      evidence :: TypeRep a -> Dict (Typeable k, Typeable a)
    evidence TypeRep a
    tr = TypeRep a
    -> (Typeable a => Dict (Typeable k, Typeable a))
    -> Dict (Typeable k, Typeable a)
    forall k (a :: k) r. TypeRep a -> (Typeable a => r) -> r
    withTypeable TypeRep a
    tr ((Typeable a => Dict (Typeable k, Typeable a))
     -> Dict (Typeable k, Typeable a))
    -> (Typeable a => Dict (Typeable k, Typeable a))
    -> Dict (Typeable k, Typeable a)
    forall a b. (a -> b) -> a -> b
    $ TypeRep k
    -> (Typeable k => Dict (Typeable k, Typeable a))
    -> Dict (Typeable k, Typeable a)
    forall k (a :: k) r. TypeRep a -> (Typeable a => r) -> r
    withTypeable (TypeRep a -> TypeRep k
    forall k (a :: k). TypeRep a -> TypeRep k
    typeRepKind TypeRep a
    tr) Dict (Typeable k, Typeable a)
    Typeable k => Dict (Typeable k, Typeable a)
    forall (c :: Constraint). c => Dict c
    Dict

    -- | From a 'Dict', takes a value in an environment where the instance
    -- witnessed by the 'Dict' is in scope, and evaluates it.
    --
    -- Essentially a deconstruction of a 'Dict' into its continuation-style
    -- form.
    --
    -- Can also be used to deconstruct an entailment, @a ':-' b@, using a context @a@.
    --
    -- @
    -- withDict :: 'Dict' c -> (c => r) -> r
    -- withDict :: a => (a ':-' c) -> (c => r) -> r
    -- @
    withDict :: HasDict c e => e -> (c => r) -> r
    withDict :: forall (c :: Constraint) e r. HasDict c e => e -> (c => r) -> r
    withDict e
    d c => r
    r = case e -> Dict c
    forall (c :: Constraint) e. HasDict c e => e -> Dict c
    evidence e
    d of
                     Dict c
    Dict -> r
    c => r
    r

    infixl 1 \\ -- required comment

    -- | Operator version of 'withDict', with the arguments flipped
    (\\) :: HasDict c e => (c => r) -> e -> r
    c => r
    r \\ :: forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
    \\ e
    d = e -> (c => r) -> r
    forall (c :: Constraint) e r. HasDict c e => e -> (c => r) -> r
    withDict e
    d r
    c => r
    r

    infixr 9 :-
    infixr 9 ⊢

    -- | Type entailment, as written with a single character.
    type (⊢) = (:-)

    -- | This is the type of entailment.
    --
    -- @a ':-' b@ is read as @a@ \"entails\" @b@.
    --
    -- With this we can actually build a category for 'Constraint' resolution.
    --
    -- e.g.
    --
    -- Because @'Eq' a@ is a superclass of @'Ord' a@, we can show that @'Ord' a@
    -- entails @'Eq' a@.
    --
    -- Because @instance 'Ord' a => 'Ord' [a]@ exists, we can show that @'Ord' a@
    -- entails @'Ord' [a]@ as well.
    --
    -- This relationship is captured in the ':-' entailment type here.
    --
    -- Since @p ':-' p@ and entailment composes, ':-' forms the arrows of a
    -- 'Category' of constraints. However, 'Category' only became sufficiently
    -- general to support this instance in GHC 7.8, so prior to 7.8 this instance
    -- is unavailable.
    --
    -- But due to the coherence of instance resolution in Haskell, this 'Category'
    -- has some very interesting properties. Notably, in the absence of
    -- @IncoherentInstances@, this category is \"thin\", which is to say that
    -- between any two objects (constraints) there is at most one distinguishable
    -- arrow.
    --
    -- This means that for instance, even though there are two ways to derive
    -- @'Ord' a ':-' 'Eq' [a]@, the answers from these two paths _must_ by
    -- construction be equal. This is a property that Haskell offers that is
    -- pretty much unique in the space of languages with things they call \"type
    -- classes\".
    --
    -- What are the two ways?
    --
    -- Well, we can go from @'Ord' a ':-' 'Eq' a@ via the
    -- superclass relationship, and then from @'Eq' a ':-' 'Eq' [a]@ via the
    -- instance, or we can go from @'Ord' a ':-' 'Ord' [a]@ via the instance
    -- then from @'Ord' [a] ':-' 'Eq' [a]@ through the superclass relationship
    -- and this diagram by definition must \"commute\".
    --
    -- Diagrammatically,
    --
    -- >                    Ord a
    -- >                ins /     \ cls
    -- >                   v       v
    -- >             Ord [a]     Eq a
    -- >                cls \     / ins
    -- >                     v   v
    -- >                    Eq [a]
    --
    -- This safety net ensures that pretty much anything you can write with this
    -- library is sensible and can't break any assumptions on the behalf of
    -- library authors.
    newtype a :- b = Sub (a => Dict b)

    type role (:-) nominal nominal

    instance (Typeable p, Typeable q, p => q) => Data (p :- q) where
      gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> (p :- q) -> c (p :- q)
    gfoldl forall d b. Data d => c (d -> b) -> d -> c b
    _ forall g. g -> c g
    z p :- q
    d = (p :- q) -> c (p :- q)
    forall g. g -> c g
    z p :- q
    d
      gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (p :- q)
    gunfold forall b r. Data b => c (b -> r) -> c r
    _ forall r. r -> c r
    z Constr
    c = case Constr -> Int
    constrIndex Constr
    c of
         Int
    1 -> (p :- q) -> c (p :- q)
    forall r. r -> c r
    z ((p => Dict q) -> p :- q
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict q
    p => Dict q
    forall (c :: Constraint). c => Dict c
    Dict)
         Int
    _ -> String -> c (p :- q)
    forall a. HasCallStack => String -> a
    error String
    "Data.Data.Data: Data.Constraint.:- constructor out of bounds"
      toConstr :: (p :- q) -> Constr
    toConstr p :- q
    _ = Constr
    subCon
      dataTypeOf :: (p :- q) -> DataType
    dataTypeOf p :- q
    _ = DataType
    subTy

    subCon :: Constr
    subCon :: Constr
    subCon = DataType -> String -> [String] -> Fixity -> Constr
    mkConstr DataType
    subTy String
    "Sub Dict" [] Fixity
    Prefix
    {-# noinline subCon #-}
    subTy :: DataType
    subTy :: DataType
    subTy = String -> [Constr] -> DataType
    mkDataType String
    "Data.Constraint.:-" [Constr
    subCon]
    {-# noinline subTy #-}

    -- | Possible since GHC 7.8, when 'Category' was made polykinded.
    instance Category (:-) where
      id :: forall (a :: Constraint). a :- a
    id  = a :- a
    forall (a :: Constraint). a :- a
    refl
      . :: forall (b :: Constraint) (c :: Constraint) (a :: Constraint).
    (b :- c) -> (a :- b) -> a :- c
    (.) = (b :- c) -> (a :- b) -> a :- c
    forall (b :: Constraint) (c :: Constraint) (a :: Constraint).
    (b :- c) -> (a :- b) -> a :- c
    trans

    -- | Assumes 'IncoherentInstances' doesn't exist.
    instance Eq (a :- b) where
      a :- b
    _ == :: (a :- b) -> (a :- b) -> Bool
    == a :- b
    _ = Bool
    True

    -- | Assumes 'IncoherentInstances' doesn't exist.
    instance Ord (a :- b) where
      compare :: (a :- b) -> (a :- b) -> Ordering
    compare a :- b
    _ a :- b
    _ = Ordering
    EQ

    instance Show (a :- b) where
      showsPrec :: Int -> (a :- b) -> ShowS
    showsPrec Int
    d a :- b
    _ = Bool -> ShowS -> ShowS
    showParen (Int
    d Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    10) (ShowS -> ShowS) -> ShowS -> ShowS
    forall a b. (a -> b) -> a -> b
    $ String -> ShowS
    showString String
    "Sub Dict"

    instance a => NFData (a :- b) where
      rnf :: (a :- b) -> ()
    rnf (Sub Dict b
    a => Dict b
    Dict) = ()

    --------------------------------------------------------------------------------
    -- Constraints form a Category
    --------------------------------------------------------------------------------

    -- | Transitivity of entailment
    --
    -- If we view @(':-')@ as a Constraint-indexed category, then this is @('.')@
    trans :: (b :- c) -> (a :- b) -> a :- c
    trans :: forall (b :: Constraint) (c :: Constraint) (a :: Constraint).
    (b :- c) -> (a :- b) -> a :- c
    trans b :- c
    f a :- b
    g = (a => Dict c) -> a :- c
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub ((a => Dict c) -> a :- c) -> (a => Dict c) -> a :- c
    forall a b. (a -> b) -> a -> b
    $ Dict c
    c => Dict c
    forall (c :: Constraint). c => Dict c
    Dict (c => Dict c) -> (b :- c) -> Dict c
    forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
    \\ b :- c
    f (b => Dict c) -> (a :- b) -> Dict c
    forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
    \\ a :- b
    g

    -- | Reflexivity of entailment
    --
    -- If we view @(':-')@ as a Constraint-indexed category, then this is 'id'
    refl :: a :- a
    refl :: forall (a :: Constraint). a :- a
    refl = (a => Dict a) -> a :- a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict a
    a => Dict a
    forall (c :: Constraint). c => Dict c
    Dict

    --------------------------------------------------------------------------------
    -- QuantifiedConstraints
    --------------------------------------------------------------------------------

    -- | Convert a quantified constraint into an entailment.
    implied :: forall a b. (a => b) => a :- b
    implied :: forall (a :: Constraint) (b :: Constraint). (a => b) => a :- b
    implied = (a => Dict b) -> a :- b
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub (Dict b
    forall (c :: Constraint). c => Dict c
    Dict :: Dict b)

    -- | The internal hom for the category of constraints.
    --
    -- This version can be passed around inside Dict, whereas (a => b) is impredicative
    --
    -- @
    -- foo :: Dict (Ord a => Eq a)
    -- foo = Dict
    -- @
    --
    -- fails to typecheck due to the lack of impredicative polymorphism, but
    --
    -- @
    -- foo :: Dict (Ord a |- Eq a)
    -- foo = Dict
    -- @
    --
    -- typechecks just fine.

    class (p => q) => p |- q
    instance (p => q) => p |- q

    --------------------------------------------------------------------------------
    -- (,) is a Bifunctor
    --------------------------------------------------------------------------------

    -- | due to the hack for the kind of @(,)@ in the current version of GHC we can't actually
    -- make instances for @(,) :: Constraint -> Constraint -> Constraint@, but we can define
    -- an equivalent type, that converts back and forth to @(,)@, and lets you hang instances.
    class (p,q) => p & q
    instance (p,q) => p & q

    -- | due to the hack for the kind of @(,)@ in the current version of GHC we can't actually
    -- make instances for @(,) :: Constraint -> Constraint -> Constraint@, but @(,)@ is a
    -- bifunctor on the category of constraints. This lets us map over both sides.
    (***) :: (a :- b) -> (c :- d) -> (a, c) :- (b, d)
    a :- b
    f *** :: forall (a :: Constraint) (b :: Constraint) (c :: Constraint)
           (d :: Constraint).
    (a :- b) -> (c :- d) -> (a, c) :- (b, d)
    *** c :- d
    g = ((a, c) => Dict (b, d)) -> (a, c) :- (b, d)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub (((a, c) => Dict (b, d)) -> (a, c) :- (b, d))
    -> ((a, c) => Dict (b, d)) -> (a, c) :- (b, d)
    forall a b. (a -> b) -> a -> b
    $ Dict (b, d)
    b => Dict (b, d)
    forall (c :: Constraint). c => Dict c
    Dict (b => Dict (b, d)) -> (a :- b) -> Dict (b, d)
    forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
    \\ a :- b
    f (d => Dict (b, d)) -> (c :- d) -> Dict (b, d)
    forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
    \\ c :- d
    g

    --------------------------------------------------------------------------------
    -- Constraints are Cartesian
    --------------------------------------------------------------------------------

    -- | Weakening a constraint product
    --
    -- The category of constraints is Cartesian. We can forget information.
    weaken1 :: (a, b) :- a
    weaken1 :: forall (a :: Constraint) (b :: Constraint). (a, b) :- a
    weaken1 = ((a, b) => Dict a) -> (a, b) :- a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict a
    (a, b) => Dict a
    forall (c :: Constraint). c => Dict c
    Dict

    -- | Weakening a constraint product
    --
    -- The category of constraints is Cartesian. We can forget information.
    weaken2 :: (a, b) :- b
    weaken2 :: forall (a :: Constraint) (b :: Constraint). (a, b) :- b
    weaken2 = ((a, b) => Dict b) -> (a, b) :- b
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict b
    (a, b) => Dict b
    forall (c :: Constraint). c => Dict c
    Dict

    strengthen1 :: Dict b -> a :- c -> a :- (b,c)
    strengthen1 :: forall (b :: Constraint) (a :: Constraint) (c :: Constraint).
    Dict b -> (a :- c) -> a :- (b, c)
    strengthen1 Dict b
    d a :- c
    e = (Dict a -> Dict b) -> a :- b
    forall (a :: Constraint) (b :: Constraint).
    (Dict a -> Dict b) -> a :- b
    unmapDict (Dict b -> Dict a -> Dict b
    forall a b. a -> b -> a
    const Dict b
    d) (a :- b) -> (a :- c) -> a :- (b, c)
    forall (a :: Constraint) (b :: Constraint) (c :: Constraint).
    (a :- b) -> (a :- c) -> a :- (b, c)
    &&& a :- c
    e

    strengthen2 :: Dict b -> a :- c -> a :- (c,b)
    strengthen2 :: forall (b :: Constraint) (a :: Constraint) (c :: Constraint).
    Dict b -> (a :- c) -> a :- (c, b)
    strengthen2 Dict b
    d a :- c
    e = a :- c
    e (a :- c) -> (a :- b) -> a :- (c, b)
    forall (a :: Constraint) (b :: Constraint) (c :: Constraint).
    (a :- b) -> (a :- c) -> a :- (b, c)
    &&& (Dict a -> Dict b) -> a :- b
    forall (a :: Constraint) (b :: Constraint).
    (Dict a -> Dict b) -> a :- b
    unmapDict (Dict b -> Dict a -> Dict b
    forall a b. a -> b -> a
    const Dict b
    d)

    -- | Contracting a constraint / diagonal morphism
    --
    -- The category of constraints is Cartesian. We can reuse information.
    contract :: a :- (a, a)
    contract :: forall (a :: Constraint). a :- (a, a)
    contract = (a => Dict (a, a)) -> a :- (a, a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (a, a)
    a => Dict (a, a)
    forall (c :: Constraint). c => Dict c
    Dict

    -- | Constraint product
    --
    -- > trans weaken1 (f &&& g) = f
    -- > trans weaken2 (f &&& g) = g
    (&&&) :: (a :- b) -> (a :- c) -> a :- (b, c)
    a :- b
    f &&& :: forall (a :: Constraint) (b :: Constraint) (c :: Constraint).
    (a :- b) -> (a :- c) -> a :- (b, c)
    &&& a :- c
    g = (a => Dict (b, c)) -> a :- (b, c)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub ((a => Dict (b, c)) -> a :- (b, c))
    -> (a => Dict (b, c)) -> a :- (b, c)
    forall a b. (a -> b) -> a -> b
    $ Dict (b, c)
    b => Dict (b, c)
    forall (c :: Constraint). c => Dict c
    Dict (b => Dict (b, c)) -> (a :- b) -> Dict (b, c)
    forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
    \\ a :- b
    f (c => Dict (b, c)) -> (a :- c) -> Dict (b, c)
    forall (c :: Constraint) e r. HasDict c e => (c => r) -> e -> r
    \\ a :- c
    g

    --------------------------------------------------------------------------------
    -- Initial and terminal morphisms
    --------------------------------------------------------------------------------

    -- | Every constraint implies truth
    --
    -- These are the terminal arrows of the category, and @()@ is the terminal object.
    --
    -- Given any constraint there is a unique entailment of the @()@ constraint from that constraint.
    top :: a :- ()
    top :: forall (a :: Constraint). a :- (() :: Constraint)
    top = (a => Dict (() :: Constraint)) -> a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict

    -- | 'Any' inhabits every kind, including 'Constraint' but is uninhabited, making it impossible to define an instance.
    class Exts.Any => Bottom where
      no :: a

    -- |
    -- This demonstrates the law of classical logic <http://en.wikipedia.org/wiki/Principle_of_explosion "ex falso quodlibet">
    bottom :: Bottom :- a
    bottom :: forall (a :: Constraint). Bottom :- a
    bottom = (Bottom => Dict a) -> Bottom :- a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict a
    Bottom => Dict a
    forall a. Bottom => a
    forall a. a
    no

    --------------------------------------------------------------------------------
    -- Dict is fully faithful
    --------------------------------------------------------------------------------

    -- | Apply an entailment to a dictionary.
    --
    -- From a category theoretic perspective 'Dict' is a functor that maps from the category
    -- of constraints (with arrows in ':-') to the category Hask of Haskell data types.
    mapDict :: (a :- b) -> Dict a -> Dict b
    mapDict :: forall (a :: Constraint) (b :: Constraint).
    (a :- b) -> Dict a -> Dict b
    mapDict a :- b
    p Dict a
    Dict = case a :- b
    p of Sub a => Dict b
    q -> Dict b
    a => Dict b
    q

    -- |
    -- This functor is fully faithful, which is to say that given any function you can write
    -- @Dict a -> Dict b@ there also exists an entailment @a :- b@ in the category of constraints
    -- that you can build.
    unmapDict :: (Dict a -> Dict b) -> a :- b
    unmapDict :: forall (a :: Constraint) (b :: Constraint).
    (Dict a -> Dict b) -> a :- b
    unmapDict Dict a -> Dict b
    f = (a => Dict b) -> a :- b
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub (Dict a -> Dict b
    f Dict a
    forall (c :: Constraint). c => Dict c
    Dict)

    type role Dict nominal

    --------------------------------------------------------------------------------
    -- Reflection
    --------------------------------------------------------------------------------

    -- | Reify the relationship between a class and its superclass constraints as a class
    --
    -- Given a definition such as
    --
    -- @
    -- class Foo a => Bar a
    -- @
    --
    -- you can capture the relationship between 'Bar a' and its superclass 'Foo a' with
    --
    -- @
    -- instance 'Class' (Foo a) (Bar a) where 'cls' = 'Sub' 'Dict'
    -- @
    --
    -- Now the user can use 'cls :: Bar a :- Foo a'
    class Class b h | h -> b where
      cls :: h :- b

    infixr 9 :=>
    -- | Reify the relationship between an instance head and its body as a class
    --
    -- Given a definition such as
    --
    -- @
    -- instance Foo a => Foo [a]
    -- @
    --
    -- you can capture the relationship between the instance head and its body with
    --
    -- @
    -- instance Foo a ':=>' Foo [a] where 'ins' = 'Sub' 'Dict'
    -- @
    class b :=> h | h -> b where
      ins :: b :- h

    -- Bootstrapping

    instance Class () (Class b a) where cls :: Class b a :- (() :: Constraint)
    cls = (Class b a => Dict (() :: Constraint))
    -> Class b a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Class b a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Class () (b :=> a) where cls :: (b :=> a) :- (() :: Constraint)
    cls = ((b :=> a) => Dict (() :: Constraint))
    -> (b :=> a) :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    (b :=> a) => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict

    instance Class b a => () :=> Class b a where ins :: (() :: Constraint) :- Class b a
    ins = ((() :: Constraint) => Dict (Class b a))
    -> (() :: Constraint) :- Class b a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Class b a)
    (() :: Constraint) => Dict (Class b a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance (b :=> a) => () :=> (b :=> a) where ins :: (() :: Constraint) :- (b :=> a)
    ins = ((() :: Constraint) => Dict (b :=> a))
    -> (() :: Constraint) :- (b :=> a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (b :=> a)
    (() :: Constraint) => Dict (b :=> a)
    forall (c :: Constraint). c => Dict c
    Dict

    instance Class () () where cls :: (() :: Constraint) :- (() :: Constraint)
    cls = ((() :: Constraint) => Dict (() :: Constraint))
    -> (() :: Constraint) :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    (() :: Constraint) => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> () where ins :: (() :: Constraint) :- (() :: Constraint)
    ins = ((() :: Constraint) => Dict (() :: Constraint))
    -> (() :: Constraint) :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    (() :: Constraint) => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Local, Prelude, Applicative, C.M.I and Data.Monoid instances

    -- Eq
    instance Class () (Eq a) where cls :: Eq a :- (() :: Constraint)
    cls = (Eq a => Dict (() :: Constraint)) -> Eq a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Eq a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq () where ins :: (() :: Constraint) :- Eq ()
    ins = ((() :: Constraint) => Dict (Eq ())) -> (() :: Constraint) :- Eq ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq ())
    (() :: Constraint) => Dict (Eq ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq Int where ins :: (() :: Constraint) :- Eq Int
    ins = ((() :: Constraint) => Dict (Eq Int))
    -> (() :: Constraint) :- Eq Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq Int)
    (() :: Constraint) => Dict (Eq Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq Bool where ins :: (() :: Constraint) :- Eq Bool
    ins = ((() :: Constraint) => Dict (Eq Bool))
    -> (() :: Constraint) :- Eq Bool
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq Bool)
    (() :: Constraint) => Dict (Eq Bool)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq Integer where ins :: (() :: Constraint) :- Eq Integer
    ins = ((() :: Constraint) => Dict (Eq Integer))
    -> (() :: Constraint) :- Eq Integer
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq Integer)
    (() :: Constraint) => Dict (Eq Integer)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq Float where ins :: (() :: Constraint) :- Eq Float
    ins = ((() :: Constraint) => Dict (Eq Float))
    -> (() :: Constraint) :- Eq Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq Float)
    (() :: Constraint) => Dict (Eq Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq Double where ins :: (() :: Constraint) :- Eq Double
    ins = ((() :: Constraint) => Dict (Eq Double))
    -> (() :: Constraint) :- Eq Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq Double)
    (() :: Constraint) => Dict (Eq Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Eq a :=> Eq [a] where ins :: Eq a :- Eq [a]
    ins = (Eq a => Dict (Eq [a])) -> Eq a :- Eq [a]
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq [a])
    Eq a => Dict (Eq [a])
    forall (c :: Constraint). c => Dict c
    Dict
    instance Eq a :=> Eq (Maybe a) where ins :: Eq a :- Eq (Maybe a)
    ins = (Eq a => Dict (Eq (Maybe a))) -> Eq a :- Eq (Maybe a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (Maybe a))
    Eq a => Dict (Eq (Maybe a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Eq a :=> Eq (Complex a) where ins :: Eq a :- Eq (Complex a)
    ins = (Eq a => Dict (Eq (Complex a))) -> Eq a :- Eq (Complex a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (Complex a))
    Eq a => Dict (Eq (Complex a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Eq a :=> Eq (Ratio a) where ins :: Eq a :- Eq (Ratio a)
    ins = (Eq a => Dict (Eq (Ratio a))) -> Eq a :- Eq (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (Ratio a))
    Eq a => Dict (Eq (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Eq a, Eq b) :=> Eq (a, b) where ins :: (Eq a, Eq b) :- Eq (a, b)
    ins = ((Eq a, Eq b) => Dict (Eq (a, b))) -> (Eq a, Eq b) :- Eq (a, b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (a, b))
    (Eq a, Eq b) => Dict (Eq (a, b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Eq a, Eq b) :=> Eq (Either a b) where ins :: (Eq a, Eq b) :- Eq (Either a b)
    ins = ((Eq a, Eq b) => Dict (Eq (Either a b)))
    -> (Eq a, Eq b) :- Eq (Either a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (Either a b))
    (Eq a, Eq b) => Dict (Eq (Either a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq (Dict a) where ins :: (() :: Constraint) :- Eq (Dict a)
    ins = ((() :: Constraint) => Dict (Eq (Dict a)))
    -> (() :: Constraint) :- Eq (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (Dict a))
    (() :: Constraint) => Dict (Eq (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq (a :- b) where ins :: (() :: Constraint) :- Eq (a :- b)
    ins = ((() :: Constraint) => Dict (Eq (a :- b)))
    -> (() :: Constraint) :- Eq (a :- b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (a :- b))
    (() :: Constraint) => Dict (Eq (a :- b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq Word where ins :: (() :: Constraint) :- Eq Word
    ins = ((() :: Constraint) => Dict (Eq Word))
    -> (() :: Constraint) :- Eq Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq Word)
    (() :: Constraint) => Dict (Eq Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Eq a :=> Eq (Identity a) where ins :: Eq a :- Eq (Identity a)
    ins = (Eq a => Dict (Eq (Identity a))) -> Eq a :- Eq (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (Identity a))
    Eq a => Dict (Eq (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Eq a :=> Eq (Const a b) where ins :: Eq a :- Eq (Const a b)
    ins = (Eq a => Dict (Eq (Const a b))) -> Eq a :- Eq (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq (Const a b))
    Eq a => Dict (Eq (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Eq Natural where ins :: (() :: Constraint) :- Eq Natural
    ins = ((() :: Constraint) => Dict (Eq Natural))
    -> (() :: Constraint) :- Eq Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq Natural)
    (() :: Constraint) => Dict (Eq Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Ord
    instance Class (Eq a) (Ord a) where cls :: Ord a :- Eq a
    cls = (Ord a => Dict (Eq a)) -> Ord a :- Eq a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq a)
    Ord a => Dict (Eq a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord () where ins :: (() :: Constraint) :- Ord ()
    ins = ((() :: Constraint) => Dict (Ord ()))
    -> (() :: Constraint) :- Ord ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord ())
    (() :: Constraint) => Dict (Ord ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord Bool where ins :: (() :: Constraint) :- Ord Bool
    ins = ((() :: Constraint) => Dict (Ord Bool))
    -> (() :: Constraint) :- Ord Bool
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Bool)
    (() :: Constraint) => Dict (Ord Bool)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord Int where ins :: (() :: Constraint) :- Ord Int
    ins = ((() :: Constraint) => Dict (Ord Int))
    -> (() :: Constraint) :- Ord Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Int)
    (() :: Constraint) => Dict (Ord Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance ():=> Ord Integer where ins :: (() :: Constraint) :- Ord Integer
    ins = ((() :: Constraint) => Dict (Ord Integer))
    -> (() :: Constraint) :- Ord Integer
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Integer)
    (() :: Constraint) => Dict (Ord Integer)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord Float where ins :: (() :: Constraint) :- Ord Float
    ins = ((() :: Constraint) => Dict (Ord Float))
    -> (() :: Constraint) :- Ord Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Float)
    (() :: Constraint) => Dict (Ord Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance ():=> Ord Double where ins :: (() :: Constraint) :- Ord Double
    ins = ((() :: Constraint) => Dict (Ord Double))
    -> (() :: Constraint) :- Ord Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Double)
    (() :: Constraint) => Dict (Ord Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord Char where ins :: (() :: Constraint) :- Ord Char
    ins = ((() :: Constraint) => Dict (Ord Char))
    -> (() :: Constraint) :- Ord Char
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Char)
    (() :: Constraint) => Dict (Ord Char)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Ord a :=> Ord (Maybe a) where ins :: Ord a :- Ord (Maybe a)
    ins = (Ord a => Dict (Ord (Maybe a))) -> Ord a :- Ord (Maybe a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (Maybe a))
    Ord a => Dict (Ord (Maybe a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Ord a :=> Ord [a] where ins :: Ord a :- Ord [a]
    ins = (Ord a => Dict (Ord [a])) -> Ord a :- Ord [a]
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord [a])
    Ord a => Dict (Ord [a])
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Ord a, Ord b) :=> Ord (a, b) where ins :: (Ord a, Ord b) :- Ord (a, b)
    ins = ((Ord a, Ord b) => Dict (Ord (a, b)))
    -> (Ord a, Ord b) :- Ord (a, b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (a, b))
    (Ord a, Ord b) => Dict (Ord (a, b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Ord a, Ord b) :=> Ord (Either a b) where ins :: (Ord a, Ord b) :- Ord (Either a b)
    ins = ((Ord a, Ord b) => Dict (Ord (Either a b)))
    -> (Ord a, Ord b) :- Ord (Either a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (Either a b))
    (Ord a, Ord b) => Dict (Ord (Either a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> Ord (Ratio a) where ins :: Integral a :- Ord (Ratio a)
    ins = (Integral a => Dict (Ord (Ratio a))) -> Integral a :- Ord (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (Ratio a))
    Integral a => Dict (Ord (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord (Dict a) where ins :: (() :: Constraint) :- Ord (Dict a)
    ins = ((() :: Constraint) => Dict (Ord (Dict a)))
    -> (() :: Constraint) :- Ord (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (Dict a))
    (() :: Constraint) => Dict (Ord (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord (a :- b) where ins :: (() :: Constraint) :- Ord (a :- b)
    ins = ((() :: Constraint) => Dict (Ord (a :- b)))
    -> (() :: Constraint) :- Ord (a :- b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (a :- b))
    (() :: Constraint) => Dict (Ord (a :- b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord Word where ins :: (() :: Constraint) :- Ord Word
    ins = ((() :: Constraint) => Dict (Ord Word))
    -> (() :: Constraint) :- Ord Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Word)
    (() :: Constraint) => Dict (Ord Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Ord a :=> Ord (Identity a) where ins :: Ord a :- Ord (Identity a)
    ins = (Ord a => Dict (Ord (Identity a))) -> Ord a :- Ord (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (Identity a))
    Ord a => Dict (Ord (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Ord a :=> Ord (Const a b) where ins :: Ord a :- Ord (Const a b)
    ins = (Ord a => Dict (Ord (Const a b))) -> Ord a :- Ord (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord (Const a b))
    Ord a => Dict (Ord (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Ord Natural where ins :: (() :: Constraint) :- Ord Natural
    ins = ((() :: Constraint) => Dict (Ord Natural))
    -> (() :: Constraint) :- Ord Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Ord Natural)
    (() :: Constraint) => Dict (Ord Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Show
    instance Class () (Show a) where cls :: Show a :- (() :: Constraint)
    cls = (Show a => Dict (() :: Constraint)) -> Show a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Show a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show () where ins :: (() :: Constraint) :- Show ()
    ins = ((() :: Constraint) => Dict (Show ()))
    -> (() :: Constraint) :- Show ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show ())
    (() :: Constraint) => Dict (Show ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show Bool where ins :: (() :: Constraint) :- Show Bool
    ins = ((() :: Constraint) => Dict (Show Bool))
    -> (() :: Constraint) :- Show Bool
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show Bool)
    (() :: Constraint) => Dict (Show Bool)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show Ordering where ins :: (() :: Constraint) :- Show Ordering
    ins = ((() :: Constraint) => Dict (Show Ordering))
    -> (() :: Constraint) :- Show Ordering
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show Ordering)
    (() :: Constraint) => Dict (Show Ordering)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show Char where ins :: (() :: Constraint) :- Show Char
    ins = ((() :: Constraint) => Dict (Show Char))
    -> (() :: Constraint) :- Show Char
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show Char)
    (() :: Constraint) => Dict (Show Char)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show Int where ins :: (() :: Constraint) :- Show Int
    ins = ((() :: Constraint) => Dict (Show Int))
    -> (() :: Constraint) :- Show Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show Int)
    (() :: Constraint) => Dict (Show Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Show a :=> Show (Complex a) where ins :: Show a :- Show (Complex a)
    ins = (Show a => Dict (Show (Complex a))) -> Show a :- Show (Complex a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (Complex a))
    Show a => Dict (Show (Complex a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Show a :=> Show [a] where ins :: Show a :- Show [a]
    ins = (Show a => Dict (Show [a])) -> Show a :- Show [a]
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show [a])
    Show a => Dict (Show [a])
    forall (c :: Constraint). c => Dict c
    Dict
    instance Show a :=> Show (Maybe a) where ins :: Show a :- Show (Maybe a)
    ins = (Show a => Dict (Show (Maybe a))) -> Show a :- Show (Maybe a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (Maybe a))
    Show a => Dict (Show (Maybe a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Show a, Show b) :=> Show (a, b) where ins :: (Show a, Show b) :- Show (a, b)
    ins = ((Show a, Show b) => Dict (Show (a, b)))
    -> (Show a, Show b) :- Show (a, b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (a, b))
    (Show a, Show b) => Dict (Show (a, b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Show a, Show b) :=> Show (Either a b) where ins :: (Show a, Show b) :- Show (Either a b)
    ins = ((Show a, Show b) => Dict (Show (Either a b)))
    -> (Show a, Show b) :- Show (Either a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (Either a b))
    (Show a, Show b) => Dict (Show (Either a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Integral a, Show a) :=> Show (Ratio a) where ins :: (Integral a, Show a) :- Show (Ratio a)
    ins = ((Integral a, Show a) => Dict (Show (Ratio a)))
    -> (Integral a, Show a) :- Show (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (Ratio a))
    (Integral a, Show a) => Dict (Show (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show (Dict a) where ins :: (() :: Constraint) :- Show (Dict a)
    ins = ((() :: Constraint) => Dict (Show (Dict a)))
    -> (() :: Constraint) :- Show (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (Dict a))
    (() :: Constraint) => Dict (Show (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show (a :- b) where ins :: (() :: Constraint) :- Show (a :- b)
    ins = ((() :: Constraint) => Dict (Show (a :- b)))
    -> (() :: Constraint) :- Show (a :- b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (a :- b))
    (() :: Constraint) => Dict (Show (a :- b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show Word where ins :: (() :: Constraint) :- Show Word
    ins = ((() :: Constraint) => Dict (Show Word))
    -> (() :: Constraint) :- Show Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show Word)
    (() :: Constraint) => Dict (Show Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Show a :=> Show (Identity a) where ins :: Show a :- Show (Identity a)
    ins = (Show a => Dict (Show (Identity a))) -> Show a :- Show (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (Identity a))
    Show a => Dict (Show (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Show a :=> Show (Const a b) where ins :: Show a :- Show (Const a b)
    ins = (Show a => Dict (Show (Const a b))) -> Show a :- Show (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show (Const a b))
    Show a => Dict (Show (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Show Natural where ins :: (() :: Constraint) :- Show Natural
    ins = ((() :: Constraint) => Dict (Show Natural))
    -> (() :: Constraint) :- Show Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Show Natural)
    (() :: Constraint) => Dict (Show Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Read
    instance Class () (Read a) where cls :: Read a :- (() :: Constraint)
    cls = (Read a => Dict (() :: Constraint)) -> Read a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Read a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Read () where ins :: (() :: Constraint) :- Read ()
    ins = ((() :: Constraint) => Dict (Read ()))
    -> (() :: Constraint) :- Read ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read ())
    (() :: Constraint) => Dict (Read ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Read Bool where ins :: (() :: Constraint) :- Read Bool
    ins = ((() :: Constraint) => Dict (Read Bool))
    -> (() :: Constraint) :- Read Bool
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read Bool)
    (() :: Constraint) => Dict (Read Bool)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Read Ordering where ins :: (() :: Constraint) :- Read Ordering
    ins = ((() :: Constraint) => Dict (Read Ordering))
    -> (() :: Constraint) :- Read Ordering
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read Ordering)
    (() :: Constraint) => Dict (Read Ordering)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Read Char where ins :: (() :: Constraint) :- Read Char
    ins = ((() :: Constraint) => Dict (Read Char))
    -> (() :: Constraint) :- Read Char
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read Char)
    (() :: Constraint) => Dict (Read Char)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Read Int where ins :: (() :: Constraint) :- Read Int
    ins = ((() :: Constraint) => Dict (Read Int))
    -> (() :: Constraint) :- Read Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read Int)
    (() :: Constraint) => Dict (Read Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Read a :=> Read (Complex a) where ins :: Read a :- Read (Complex a)
    ins = (Read a => Dict (Read (Complex a))) -> Read a :- Read (Complex a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (Complex a))
    Read a => Dict (Read (Complex a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Read a :=> Read [a] where ins :: Read a :- Read [a]
    ins = (Read a => Dict (Read [a])) -> Read a :- Read [a]
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read [a])
    Read a => Dict (Read [a])
    forall (c :: Constraint). c => Dict c
    Dict
    instance Read a :=> Read (Maybe a) where ins :: Read a :- Read (Maybe a)
    ins = (Read a => Dict (Read (Maybe a))) -> Read a :- Read (Maybe a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (Maybe a))
    Read a => Dict (Read (Maybe a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Read a, Read b) :=> Read (a, b) where ins :: (Read a, Read b) :- Read (a, b)
    ins = ((Read a, Read b) => Dict (Read (a, b)))
    -> (Read a, Read b) :- Read (a, b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (a, b))
    (Read a, Read b) => Dict (Read (a, b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Read a, Read b) :=> Read (Either a b) where ins :: (Read a, Read b) :- Read (Either a b)
    ins = ((Read a, Read b) => Dict (Read (Either a b)))
    -> (Read a, Read b) :- Read (Either a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (Either a b))
    (Read a, Read b) => Dict (Read (Either a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Integral a, Read a) :=> Read (Ratio a) where ins :: (Integral a, Read a) :- Read (Ratio a)
    ins = ((Integral a, Read a) => Dict (Read (Ratio a)))
    -> (Integral a, Read a) :- Read (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (Ratio a))
    (Integral a, Read a) => Dict (Read (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Read Word where ins :: (() :: Constraint) :- Read Word
    ins = ((() :: Constraint) => Dict (Read Word))
    -> (() :: Constraint) :- Read Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read Word)
    (() :: Constraint) => Dict (Read Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Read a :=> Read (Identity a) where ins :: Read a :- Read (Identity a)
    ins = (Read a => Dict (Read (Identity a))) -> Read a :- Read (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (Identity a))
    Read a => Dict (Read (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Read a :=> Read (Const a b) where ins :: Read a :- Read (Const a b)
    ins = (Read a => Dict (Read (Const a b))) -> Read a :- Read (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (Const a b))
    Read a => Dict (Read (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Read Natural where ins :: (() :: Constraint) :- Read Natural
    ins = ((() :: Constraint) => Dict (Read Natural))
    -> (() :: Constraint) :- Read Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read Natural)
    (() :: Constraint) => Dict (Read Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Enum
    instance Class () (Enum a) where cls :: Enum a :- (() :: Constraint)
    cls = (Enum a => Dict (() :: Constraint)) -> Enum a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Enum a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum () where ins :: (() :: Constraint) :- Enum ()
    ins = ((() :: Constraint) => Dict (Enum ()))
    -> (() :: Constraint) :- Enum ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum ())
    (() :: Constraint) => Dict (Enum ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Bool where ins :: (() :: Constraint) :- Enum Bool
    ins = ((() :: Constraint) => Dict (Enum Bool))
    -> (() :: Constraint) :- Enum Bool
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Bool)
    (() :: Constraint) => Dict (Enum Bool)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Ordering where ins :: (() :: Constraint) :- Enum Ordering
    ins = ((() :: Constraint) => Dict (Enum Ordering))
    -> (() :: Constraint) :- Enum Ordering
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Ordering)
    (() :: Constraint) => Dict (Enum Ordering)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Char where ins :: (() :: Constraint) :- Enum Char
    ins = ((() :: Constraint) => Dict (Enum Char))
    -> (() :: Constraint) :- Enum Char
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Char)
    (() :: Constraint) => Dict (Enum Char)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Int where ins :: (() :: Constraint) :- Enum Int
    ins = ((() :: Constraint) => Dict (Enum Int))
    -> (() :: Constraint) :- Enum Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Int)
    (() :: Constraint) => Dict (Enum Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Integer where ins :: (() :: Constraint) :- Enum Integer
    ins = ((() :: Constraint) => Dict (Enum Integer))
    -> (() :: Constraint) :- Enum Integer
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Integer)
    (() :: Constraint) => Dict (Enum Integer)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Float where ins :: (() :: Constraint) :- Enum Float
    ins = ((() :: Constraint) => Dict (Enum Float))
    -> (() :: Constraint) :- Enum Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Float)
    (() :: Constraint) => Dict (Enum Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Double where ins :: (() :: Constraint) :- Enum Double
    ins = ((() :: Constraint) => Dict (Enum Double))
    -> (() :: Constraint) :- Enum Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Double)
    (() :: Constraint) => Dict (Enum Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> Enum (Ratio a) where ins :: Integral a :- Enum (Ratio a)
    ins = (Integral a => Dict (Enum (Ratio a)))
    -> Integral a :- Enum (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum (Ratio a))
    Integral a => Dict (Enum (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Word where ins :: (() :: Constraint) :- Enum Word
    ins = ((() :: Constraint) => Dict (Enum Word))
    -> (() :: Constraint) :- Enum Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Word)
    (() :: Constraint) => Dict (Enum Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Enum a :=> Enum (Identity a) where ins :: Enum a :- Enum (Identity a)
    ins = (Enum a => Dict (Enum (Identity a))) -> Enum a :- Enum (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum (Identity a))
    Enum a => Dict (Enum (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Enum a :=> Enum (Const a b) where ins :: Enum a :- Enum (Const a b)
    ins = (Enum a => Dict (Enum (Const a b))) -> Enum a :- Enum (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum (Const a b))
    Enum a => Dict (Enum (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Enum Natural where ins :: (() :: Constraint) :- Enum Natural
    ins = ((() :: Constraint) => Dict (Enum Natural))
    -> (() :: Constraint) :- Enum Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum Natural)
    (() :: Constraint) => Dict (Enum Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Bounded
    instance Class () (Bounded a) where cls :: Bounded a :- (() :: Constraint)
    cls = (Bounded a => Dict (() :: Constraint))
    -> Bounded a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Bounded a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bounded () where ins :: (() :: Constraint) :- Bounded ()
    ins = ((() :: Constraint) => Dict (Bounded ()))
    -> (() :: Constraint) :- Bounded ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded ())
    (() :: Constraint) => Dict (Bounded ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bounded Ordering where ins :: (() :: Constraint) :- Bounded Ordering
    ins = ((() :: Constraint) => Dict (Bounded Ordering))
    -> (() :: Constraint) :- Bounded Ordering
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded Ordering)
    (() :: Constraint) => Dict (Bounded Ordering)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bounded Bool where ins :: (() :: Constraint) :- Bounded Bool
    ins = ((() :: Constraint) => Dict (Bounded Bool))
    -> (() :: Constraint) :- Bounded Bool
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded Bool)
    (() :: Constraint) => Dict (Bounded Bool)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bounded Int where ins :: (() :: Constraint) :- Bounded Int
    ins = ((() :: Constraint) => Dict (Bounded Int))
    -> (() :: Constraint) :- Bounded Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded Int)
    (() :: Constraint) => Dict (Bounded Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bounded Char where ins :: (() :: Constraint) :- Bounded Char
    ins = ((() :: Constraint) => Dict (Bounded Char))
    -> (() :: Constraint) :- Bounded Char
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded Char)
    (() :: Constraint) => Dict (Bounded Char)
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Bounded a, Bounded b) :=> Bounded (a,b) where ins :: (Bounded a, Bounded b) :- Bounded (a, b)
    ins = ((Bounded a, Bounded b) => Dict (Bounded (a, b)))
    -> (Bounded a, Bounded b) :- Bounded (a, b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded (a, b))
    (Bounded a, Bounded b) => Dict (Bounded (a, b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bounded Word where ins :: (() :: Constraint) :- Bounded Word
    ins = ((() :: Constraint) => Dict (Bounded Word))
    -> (() :: Constraint) :- Bounded Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded Word)
    (() :: Constraint) => Dict (Bounded Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Bounded a :=> Bounded (Identity a) where ins :: Bounded a :- Bounded (Identity a)
    ins = (Bounded a => Dict (Bounded (Identity a)))
    -> Bounded a :- Bounded (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded (Identity a))
    Bounded a => Dict (Bounded (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Bounded a :=> Bounded (Const a b) where ins :: Bounded a :- Bounded (Const a b)
    ins = (Bounded a => Dict (Bounded (Const a b)))
    -> Bounded a :- Bounded (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded (Const a b))
    Bounded a => Dict (Bounded (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Num
    instance Class () (Num a) where cls :: Num a :- (() :: Constraint)
    cls = (Num a => Dict (() :: Constraint)) -> Num a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Num a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Num Int where ins :: (() :: Constraint) :- Num Int
    ins = ((() :: Constraint) => Dict (Num Int))
    -> (() :: Constraint) :- Num Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num Int)
    (() :: Constraint) => Dict (Num Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Num Integer where ins :: (() :: Constraint) :- Num Integer
    ins = ((() :: Constraint) => Dict (Num Integer))
    -> (() :: Constraint) :- Num Integer
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num Integer)
    (() :: Constraint) => Dict (Num Integer)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Num Float where ins :: (() :: Constraint) :- Num Float
    ins = ((() :: Constraint) => Dict (Num Float))
    -> (() :: Constraint) :- Num Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num Float)
    (() :: Constraint) => Dict (Num Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Num Double where ins :: (() :: Constraint) :- Num Double
    ins = ((() :: Constraint) => Dict (Num Double))
    -> (() :: Constraint) :- Num Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num Double)
    (() :: Constraint) => Dict (Num Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance RealFloat a :=> Num (Complex a) where ins :: RealFloat a :- Num (Complex a)
    ins = (RealFloat a => Dict (Num (Complex a)))
    -> RealFloat a :- Num (Complex a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num (Complex a))
    RealFloat a => Dict (Num (Complex a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> Num (Ratio a) where ins :: Integral a :- Num (Ratio a)
    ins = (Integral a => Dict (Num (Ratio a))) -> Integral a :- Num (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num (Ratio a))
    Integral a => Dict (Num (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Num Word where ins :: (() :: Constraint) :- Num Word
    ins = ((() :: Constraint) => Dict (Num Word))
    -> (() :: Constraint) :- Num Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num Word)
    (() :: Constraint) => Dict (Num Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Num a :=> Num (Identity a) where ins :: Num a :- Num (Identity a)
    ins = (Num a => Dict (Num (Identity a))) -> Num a :- Num (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num (Identity a))
    Num a => Dict (Num (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Num a :=> Num (Const a b) where ins :: Num a :- Num (Const a b)
    ins = (Num a => Dict (Num (Const a b))) -> Num a :- Num (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num (Const a b))
    Num a => Dict (Num (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Num Natural where ins :: (() :: Constraint) :- Num Natural
    ins = ((() :: Constraint) => Dict (Num Natural))
    -> (() :: Constraint) :- Num Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num Natural)
    (() :: Constraint) => Dict (Num Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Real
    instance Class (Num a, Ord a) (Real a) where cls :: Real a :- (Num a, Ord a)
    cls = (Real a => Dict (Num a, Ord a)) -> Real a :- (Num a, Ord a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num a, Ord a)
    Real a => Dict (Num a, Ord a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Real Int where ins :: (() :: Constraint) :- Real Int
    ins = ((() :: Constraint) => Dict (Real Int))
    -> (() :: Constraint) :- Real Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real Int)
    (() :: Constraint) => Dict (Real Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Real Integer where ins :: (() :: Constraint) :- Real Integer
    ins = ((() :: Constraint) => Dict (Real Integer))
    -> (() :: Constraint) :- Real Integer
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real Integer)
    (() :: Constraint) => Dict (Real Integer)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Real Float where ins :: (() :: Constraint) :- Real Float
    ins = ((() :: Constraint) => Dict (Real Float))
    -> (() :: Constraint) :- Real Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real Float)
    (() :: Constraint) => Dict (Real Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Real Double where ins :: (() :: Constraint) :- Real Double
    ins = ((() :: Constraint) => Dict (Real Double))
    -> (() :: Constraint) :- Real Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real Double)
    (() :: Constraint) => Dict (Real Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> Real (Ratio a) where ins :: Integral a :- Real (Ratio a)
    ins = (Integral a => Dict (Real (Ratio a)))
    -> Integral a :- Real (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real (Ratio a))
    Integral a => Dict (Real (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Real Word where ins :: (() :: Constraint) :- Real Word
    ins = ((() :: Constraint) => Dict (Real Word))
    -> (() :: Constraint) :- Real Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real Word)
    (() :: Constraint) => Dict (Real Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Real a :=> Real (Identity a) where ins :: Real a :- Real (Identity a)
    ins = (Real a => Dict (Real (Identity a))) -> Real a :- Real (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real (Identity a))
    Real a => Dict (Real (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Real a :=> Real (Const a b) where ins :: Real a :- Real (Const a b)
    ins = (Real a => Dict (Real (Const a b))) -> Real a :- Real (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real (Const a b))
    Real a => Dict (Real (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Real Natural where ins :: (() :: Constraint) :- Real Natural
    ins = ((() :: Constraint) => Dict (Real Natural))
    -> (() :: Constraint) :- Real Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real Natural)
    (() :: Constraint) => Dict (Real Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Integral
    instance Class (Real a, Enum a) (Integral a) where cls :: Integral a :- (Real a, Enum a)
    cls = (Integral a => Dict (Real a, Enum a))
    -> Integral a :- (Real a, Enum a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real a, Enum a)
    Integral a => Dict (Real a, Enum a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Integral Int where ins :: (() :: Constraint) :- Integral Int
    ins = ((() :: Constraint) => Dict (Integral Int))
    -> (() :: Constraint) :- Integral Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Integral Int)
    (() :: Constraint) => Dict (Integral Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Integral Integer where ins :: (() :: Constraint) :- Integral Integer
    ins = ((() :: Constraint) => Dict (Integral Integer))
    -> (() :: Constraint) :- Integral Integer
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Integral Integer)
    (() :: Constraint) => Dict (Integral Integer)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Integral Word where ins :: (() :: Constraint) :- Integral Word
    ins = ((() :: Constraint) => Dict (Integral Word))
    -> (() :: Constraint) :- Integral Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Integral Word)
    (() :: Constraint) => Dict (Integral Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> Integral (Identity a) where ins :: Integral a :- Integral (Identity a)
    ins = (Integral a => Dict (Integral (Identity a)))
    -> Integral a :- Integral (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Integral (Identity a))
    Integral a => Dict (Integral (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> Integral (Const a b) where ins :: Integral a :- Integral (Const a b)
    ins = (Integral a => Dict (Integral (Const a b)))
    -> Integral a :- Integral (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Integral (Const a b))
    Integral a => Dict (Integral (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Integral Natural where ins :: (() :: Constraint) :- Integral Natural
    ins = ((() :: Constraint) => Dict (Integral Natural))
    -> (() :: Constraint) :- Integral Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Integral Natural)
    (() :: Constraint) => Dict (Integral Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Bits
    instance Class (Eq a) (Bits a) where cls :: Bits a :- Eq a
    cls = (Bits a => Dict (Eq a)) -> Bits a :- Eq a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Eq a)
    Bits a => Dict (Eq a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bits Bool where ins :: (() :: Constraint) :- Bits Bool
    ins = ((() :: Constraint) => Dict (Bits Bool))
    -> (() :: Constraint) :- Bits Bool
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bits Bool)
    (() :: Constraint) => Dict (Bits Bool)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bits Int where ins :: (() :: Constraint) :- Bits Int
    ins = ((() :: Constraint) => Dict (Bits Int))
    -> (() :: Constraint) :- Bits Int
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bits Int)
    (() :: Constraint) => Dict (Bits Int)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bits Integer where ins :: (() :: Constraint) :- Bits Integer
    ins = ((() :: Constraint) => Dict (Bits Integer))
    -> (() :: Constraint) :- Bits Integer
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bits Integer)
    (() :: Constraint) => Dict (Bits Integer)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bits Word where ins :: (() :: Constraint) :- Bits Word
    ins = ((() :: Constraint) => Dict (Bits Word))
    -> (() :: Constraint) :- Bits Word
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bits Word)
    (() :: Constraint) => Dict (Bits Word)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Bits a :=> Bits (Identity a) where ins :: Bits a :- Bits (Identity a)
    ins = (Bits a => Dict (Bits (Identity a))) -> Bits a :- Bits (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bits (Identity a))
    Bits a => Dict (Bits (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Bits a :=> Bits (Const a b) where ins :: Bits a :- Bits (Const a b)
    ins = (Bits a => Dict (Bits (Const a b))) -> Bits a :- Bits (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bits (Const a b))
    Bits a => Dict (Bits (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Bits Natural where ins :: (() :: Constraint) :- Bits Natural
    ins = ((() :: Constraint) => Dict (Bits Natural))
    -> (() :: Constraint) :- Bits Natural
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bits Natural)
    (() :: Constraint) => Dict (Bits Natural)
    forall (c :: Constraint). c => Dict c
    Dict

    -- Fractional
    instance Class (Num a) (Fractional a) where cls :: Fractional a :- Num a
    cls = (Fractional a => Dict (Num a)) -> Fractional a :- Num a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Num a)
    Fractional a => Dict (Num a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Fractional Float where ins :: (() :: Constraint) :- Fractional Float
    ins = ((() :: Constraint) => Dict (Fractional Float))
    -> (() :: Constraint) :- Fractional Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Fractional Float)
    (() :: Constraint) => Dict (Fractional Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Fractional Double where ins :: (() :: Constraint) :- Fractional Double
    ins = ((() :: Constraint) => Dict (Fractional Double))
    -> (() :: Constraint) :- Fractional Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Fractional Double)
    (() :: Constraint) => Dict (Fractional Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance RealFloat a :=> Fractional (Complex a) where ins :: RealFloat a :- Fractional (Complex a)
    ins = (RealFloat a => Dict (Fractional (Complex a)))
    -> RealFloat a :- Fractional (Complex a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Fractional (Complex a))
    RealFloat a => Dict (Fractional (Complex a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> Fractional (Ratio a) where ins :: Integral a :- Fractional (Ratio a)
    ins = (Integral a => Dict (Fractional (Ratio a)))
    -> Integral a :- Fractional (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Fractional (Ratio a))
    Integral a => Dict (Fractional (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Fractional a :=> Fractional (Identity a) where ins :: Fractional a :- Fractional (Identity a)
    ins = (Fractional a => Dict (Fractional (Identity a)))
    -> Fractional a :- Fractional (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Fractional (Identity a))
    Fractional a => Dict (Fractional (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Fractional a :=> Fractional (Const a b) where ins :: Fractional a :- Fractional (Const a b)
    ins = (Fractional a => Dict (Fractional (Const a b)))
    -> Fractional a :- Fractional (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Fractional (Const a b))
    Fractional a => Dict (Fractional (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Floating
    instance Class (Fractional a) (Floating a) where cls :: Floating a :- Fractional a
    cls = (Floating a => Dict (Fractional a)) -> Floating a :- Fractional a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Fractional a)
    Floating a => Dict (Fractional a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Floating Float where ins :: (() :: Constraint) :- Floating Float
    ins = ((() :: Constraint) => Dict (Floating Float))
    -> (() :: Constraint) :- Floating Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Floating Float)
    (() :: Constraint) => Dict (Floating Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Floating Double where ins :: (() :: Constraint) :- Floating Double
    ins = ((() :: Constraint) => Dict (Floating Double))
    -> (() :: Constraint) :- Floating Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Floating Double)
    (() :: Constraint) => Dict (Floating Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance RealFloat a :=> Floating (Complex a) where ins :: RealFloat a :- Floating (Complex a)
    ins = (RealFloat a => Dict (Floating (Complex a)))
    -> RealFloat a :- Floating (Complex a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Floating (Complex a))
    RealFloat a => Dict (Floating (Complex a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Floating a :=> Floating (Identity a) where ins :: Floating a :- Floating (Identity a)
    ins = (Floating a => Dict (Floating (Identity a)))
    -> Floating a :- Floating (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Floating (Identity a))
    Floating a => Dict (Floating (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Floating a :=> Floating (Const a b) where ins :: Floating a :- Floating (Const a b)
    ins = (Floating a => Dict (Floating (Const a b)))
    -> Floating a :- Floating (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Floating (Const a b))
    Floating a => Dict (Floating (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict

    -- RealFrac
    instance Class (Real a, Fractional a) (RealFrac a) where cls :: RealFrac a :- (Real a, Fractional a)
    cls = (RealFrac a => Dict (Real a, Fractional a))
    -> RealFrac a :- (Real a, Fractional a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Real a, Fractional a)
    RealFrac a => Dict (Real a, Fractional a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> RealFrac Float where ins :: (() :: Constraint) :- RealFrac Float
    ins = ((() :: Constraint) => Dict (RealFrac Float))
    -> (() :: Constraint) :- RealFrac Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFrac Float)
    (() :: Constraint) => Dict (RealFrac Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> RealFrac Double where ins :: (() :: Constraint) :- RealFrac Double
    ins = ((() :: Constraint) => Dict (RealFrac Double))
    -> (() :: Constraint) :- RealFrac Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFrac Double)
    (() :: Constraint) => Dict (RealFrac Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Integral a :=> RealFrac (Ratio a) where ins :: Integral a :- RealFrac (Ratio a)
    ins = (Integral a => Dict (RealFrac (Ratio a)))
    -> Integral a :- RealFrac (Ratio a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFrac (Ratio a))
    Integral a => Dict (RealFrac (Ratio a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance RealFrac a :=> RealFrac (Identity a) where ins :: RealFrac a :- RealFrac (Identity a)
    ins = (RealFrac a => Dict (RealFrac (Identity a)))
    -> RealFrac a :- RealFrac (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFrac (Identity a))
    RealFrac a => Dict (RealFrac (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance RealFrac a :=> RealFrac (Const a b) where ins :: RealFrac a :- RealFrac (Const a b)
    ins = (RealFrac a => Dict (RealFrac (Const a b)))
    -> RealFrac a :- RealFrac (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFrac (Const a b))
    RealFrac a => Dict (RealFrac (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict

    -- RealFloat
    instance Class (RealFrac a, Floating a) (RealFloat a) where cls :: RealFloat a :- (RealFrac a, Floating a)
    cls = (RealFloat a => Dict (RealFrac a, Floating a))
    -> RealFloat a :- (RealFrac a, Floating a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFrac a, Floating a)
    RealFloat a => Dict (RealFrac a, Floating a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> RealFloat Float where ins :: (() :: Constraint) :- RealFloat Float
    ins = ((() :: Constraint) => Dict (RealFloat Float))
    -> (() :: Constraint) :- RealFloat Float
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFloat Float)
    (() :: Constraint) => Dict (RealFloat Float)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> RealFloat Double where ins :: (() :: Constraint) :- RealFloat Double
    ins = ((() :: Constraint) => Dict (RealFloat Double))
    -> (() :: Constraint) :- RealFloat Double
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFloat Double)
    (() :: Constraint) => Dict (RealFloat Double)
    forall (c :: Constraint). c => Dict c
    Dict
    instance RealFloat a :=> RealFloat (Identity a) where ins :: RealFloat a :- RealFloat (Identity a)
    ins = (RealFloat a => Dict (RealFloat (Identity a)))
    -> RealFloat a :- RealFloat (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFloat (Identity a))
    RealFloat a => Dict (RealFloat (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance RealFloat a :=> RealFloat (Const a b) where ins :: RealFloat a :- RealFloat (Const a b)
    ins = (RealFloat a => Dict (RealFloat (Const a b)))
    -> RealFloat a :- RealFloat (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (RealFloat (Const a b))
    RealFloat a => Dict (RealFloat (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Semigroup
    instance Class () (Semigroup a) where cls :: Semigroup a :- (() :: Constraint)
    cls = (Semigroup a => Dict (() :: Constraint))
    -> Semigroup a :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Semigroup a => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Semigroup () where ins :: (() :: Constraint) :- Semigroup ()
    ins = ((() :: Constraint) => Dict (Semigroup ()))
    -> (() :: Constraint) :- Semigroup ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup ())
    (() :: Constraint) => Dict (Semigroup ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Semigroup Ordering where ins :: (() :: Constraint) :- Semigroup Ordering
    ins = ((() :: Constraint) => Dict (Semigroup Ordering))
    -> (() :: Constraint) :- Semigroup Ordering
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup Ordering)
    (() :: Constraint) => Dict (Semigroup Ordering)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Semigroup [a] where ins :: (() :: Constraint) :- Semigroup [a]
    ins = ((() :: Constraint) => Dict (Semigroup [a]))
    -> (() :: Constraint) :- Semigroup [a]
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup [a])
    (() :: Constraint) => Dict (Semigroup [a])
    forall (c :: Constraint). c => Dict c
    Dict
    instance Semigroup a :=> Semigroup (Maybe a) where ins :: Semigroup a :- Semigroup (Maybe a)
    ins = (Semigroup a => Dict (Semigroup (Maybe a)))
    -> Semigroup a :- Semigroup (Maybe a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup (Maybe a))
    Semigroup a => Dict (Semigroup (Maybe a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Semigroup a, Semigroup b) :=> Semigroup (a, b) where ins :: (Semigroup a, Semigroup b) :- Semigroup (a, b)
    ins = ((Semigroup a, Semigroup b) => Dict (Semigroup (a, b)))
    -> (Semigroup a, Semigroup b) :- Semigroup (a, b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup (a, b))
    (Semigroup a, Semigroup b) => Dict (Semigroup (a, b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Semigroup a :=> Semigroup (Const a b) where ins :: Semigroup a :- Semigroup (Const a b)
    ins = (Semigroup a => Dict (Semigroup (Const a b)))
    -> Semigroup a :- Semigroup (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup (Const a b))
    Semigroup a => Dict (Semigroup (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Semigroup a :=> Semigroup (Identity a) where ins :: Semigroup a :- Semigroup (Identity a)
    ins = (Semigroup a => Dict (Semigroup (Identity a)))
    -> Semigroup a :- Semigroup (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup (Identity a))
    Semigroup a => Dict (Semigroup (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Semigroup a :=> Semigroup (IO a) where ins :: Semigroup a :- Semigroup (IO a)
    ins = (Semigroup a => Dict (Semigroup (IO a)))
    -> Semigroup a :- Semigroup (IO a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup (IO a))
    Semigroup a => Dict (Semigroup (IO a))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Monoid
    instance Class (Semigroup a) (Monoid a) where cls :: Monoid a :- Semigroup a
    cls = (Monoid a => Dict (Semigroup a)) -> Monoid a :- Semigroup a
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup a)
    Monoid a => Dict (Semigroup a)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monoid () where ins :: (() :: Constraint) :- Monoid ()
    ins = ((() :: Constraint) => Dict (Monoid ()))
    -> (() :: Constraint) :- Monoid ()
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid ())
    (() :: Constraint) => Dict (Monoid ())
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monoid Ordering where ins :: (() :: Constraint) :- Monoid Ordering
    ins = ((() :: Constraint) => Dict (Monoid Ordering))
    -> (() :: Constraint) :- Monoid Ordering
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid Ordering)
    (() :: Constraint) => Dict (Monoid Ordering)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monoid [a] where ins :: (() :: Constraint) :- Monoid [a]
    ins = ((() :: Constraint) => Dict (Monoid [a]))
    -> (() :: Constraint) :- Monoid [a]
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid [a])
    (() :: Constraint) => Dict (Monoid [a])
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monoid a :=> Monoid (Maybe a) where ins :: Monoid a :- Monoid (Maybe a)
    ins = (Monoid a => Dict (Monoid (Maybe a)))
    -> Monoid a :- Monoid (Maybe a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid (Maybe a))
    Monoid a => Dict (Monoid (Maybe a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance (Monoid a, Monoid b) :=> Monoid (a, b) where ins :: (Monoid a, Monoid b) :- Monoid (a, b)
    ins = ((Monoid a, Monoid b) => Dict (Monoid (a, b)))
    -> (Monoid a, Monoid b) :- Monoid (a, b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid (a, b))
    (Monoid a, Monoid b) => Dict (Monoid (a, b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monoid a :=> Monoid (Const a b) where ins :: Monoid a :- Monoid (Const a b)
    ins = (Monoid a => Dict (Monoid (Const a b)))
    -> Monoid a :- Monoid (Const a b)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid (Const a b))
    Monoid a => Dict (Monoid (Const a b))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monoid a :=> Monoid (Identity a) where ins :: Monoid a :- Monoid (Identity a)
    ins = (Monoid a => Dict (Monoid (Identity a)))
    -> Monoid a :- Monoid (Identity a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid (Identity a))
    Monoid a => Dict (Monoid (Identity a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monoid a :=> Monoid (IO a) where ins :: Monoid a :- Monoid (IO a)
    ins = (Monoid a => Dict (Monoid (IO a))) -> Monoid a :- Monoid (IO a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid (IO a))
    Monoid a => Dict (Monoid (IO a))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Functor
    instance Class () (Functor f) where cls :: Functor f :- (() :: Constraint)
    cls = (Functor f => Dict (() :: Constraint))
    -> Functor f :- (() :: Constraint)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (() :: Constraint)
    Functor f => Dict (() :: Constraint)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor [] where ins :: (() :: Constraint) :- Functor []
    ins = ((() :: Constraint) => Dict (Functor []))
    -> (() :: Constraint) :- Functor []
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor [])
    (() :: Constraint) => Dict (Functor [])
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor Maybe where ins :: (() :: Constraint) :- Functor Maybe
    ins = ((() :: Constraint) => Dict (Functor Maybe))
    -> (() :: Constraint) :- Functor Maybe
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor Maybe)
    (() :: Constraint) => Dict (Functor Maybe)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor (Either a) where ins :: (() :: Constraint) :- Functor (Either a)
    ins = ((() :: Constraint) => Dict (Functor (Either a)))
    -> (() :: Constraint) :- Functor (Either a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor (Either a))
    (() :: Constraint) => Dict (Functor (Either a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor ((->) a) where ins :: (() :: Constraint) :- Functor ((->) a)
    ins = ((() :: Constraint) => Dict (Functor ((->) a)))
    -> (() :: Constraint) :- Functor ((->) a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor ((->) a))
    (() :: Constraint) => Dict (Functor ((->) a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor ((,) a) where ins :: (() :: Constraint) :- Functor ((,) a)
    ins = ((() :: Constraint) => Dict (Functor ((,) a)))
    -> (() :: Constraint) :- Functor ((,) a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor ((,) a))
    (() :: Constraint) => Dict (Functor ((,) a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor IO where ins :: (() :: Constraint) :- Functor IO
    ins = ((() :: Constraint) => Dict (Functor IO))
    -> (() :: Constraint) :- Functor IO
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor IO)
    (() :: Constraint) => Dict (Functor IO)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monad m :=> Functor (WrappedMonad m) where ins :: Monad m :- Functor (WrappedMonad m)
    ins = (Monad m => Dict (Functor (WrappedMonad m)))
    -> Monad m :- Functor (WrappedMonad m)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor (WrappedMonad m))
    Monad m => Dict (Functor (WrappedMonad m))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor Identity where ins :: (() :: Constraint) :- Functor Identity
    ins = ((() :: Constraint) => Dict (Functor Identity))
    -> (() :: Constraint) :- Functor Identity
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor Identity)
    (() :: Constraint) => Dict (Functor Identity)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Functor (Const a) where ins :: (() :: Constraint) :- Functor (Const a)
    ins = ((() :: Constraint) => Dict (Functor (Const a)))
    -> (() :: Constraint) :- Functor (Const a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor (Const a))
    (() :: Constraint) => Dict (Functor (Const a))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Applicative
    instance Class (Functor f) (Applicative f) where cls :: Applicative f :- Functor f
    cls = (Applicative f => Dict (Functor f)) -> Applicative f :- Functor f
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Functor f)
    Applicative f => Dict (Functor f)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Applicative [] where ins :: (() :: Constraint) :- Applicative []
    ins = ((() :: Constraint) => Dict (Applicative []))
    -> (() :: Constraint) :- Applicative []
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative [])
    (() :: Constraint) => Dict (Applicative [])
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Applicative Maybe where ins :: (() :: Constraint) :- Applicative Maybe
    ins = ((() :: Constraint) => Dict (Applicative Maybe))
    -> (() :: Constraint) :- Applicative Maybe
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative Maybe)
    (() :: Constraint) => Dict (Applicative Maybe)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Applicative (Either a) where ins :: (() :: Constraint) :- Applicative (Either a)
    ins = ((() :: Constraint) => Dict (Applicative (Either a)))
    -> (() :: Constraint) :- Applicative (Either a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative (Either a))
    (() :: Constraint) => Dict (Applicative (Either a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Applicative ((->)a) where ins :: (() :: Constraint) :- Applicative ((->) a)
    ins = ((() :: Constraint) => Dict (Applicative ((->) a)))
    -> (() :: Constraint) :- Applicative ((->) a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative ((->) a))
    (() :: Constraint) => Dict (Applicative ((->) a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Applicative IO where ins :: (() :: Constraint) :- Applicative IO
    ins = ((() :: Constraint) => Dict (Applicative IO))
    -> (() :: Constraint) :- Applicative IO
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative IO)
    (() :: Constraint) => Dict (Applicative IO)
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monoid a :=> Applicative ((,)a) where ins :: Monoid a :- Applicative ((,) a)
    ins = (Monoid a => Dict (Applicative ((,) a)))
    -> Monoid a :- Applicative ((,) a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative ((,) a))
    Monoid a => Dict (Applicative ((,) a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monoid a :=> Applicative (Const a) where ins :: Monoid a :- Applicative (Const a)
    ins = (Monoid a => Dict (Applicative (Const a)))
    -> Monoid a :- Applicative (Const a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative (Const a))
    Monoid a => Dict (Applicative (Const a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Monad m :=> Applicative (WrappedMonad m) where ins :: Monad m :- Applicative (WrappedMonad m)
    ins = (Monad m => Dict (Applicative (WrappedMonad m)))
    -> Monad m :- Applicative (WrappedMonad m)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative (WrappedMonad m))
    Monad m => Dict (Applicative (WrappedMonad m))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Alternative
    instance Class (Applicative f) (Alternative f) where cls :: Alternative f :- Applicative f
    cls = (Alternative f => Dict (Applicative f))
    -> Alternative f :- Applicative f
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative f)
    Alternative f => Dict (Applicative f)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Alternative [] where ins :: (() :: Constraint) :- Alternative []
    ins = ((() :: Constraint) => Dict (Alternative []))
    -> (() :: Constraint) :- Alternative []
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Alternative [])
    (() :: Constraint) => Dict (Alternative [])
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Alternative Maybe where ins :: (() :: Constraint) :- Alternative Maybe
    ins = ((() :: Constraint) => Dict (Alternative Maybe))
    -> (() :: Constraint) :- Alternative Maybe
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Alternative Maybe)
    (() :: Constraint) => Dict (Alternative Maybe)
    forall (c :: Constraint). c => Dict c
    Dict
    instance MonadPlus m :=> Alternative (WrappedMonad m) where ins :: MonadPlus m :- Alternative (WrappedMonad m)
    ins = (MonadPlus m => Dict (Alternative (WrappedMonad m)))
    -> MonadPlus m :- Alternative (WrappedMonad m)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Alternative (WrappedMonad m))
    MonadPlus m => Dict (Alternative (WrappedMonad m))
    forall (c :: Constraint). c => Dict c
    Dict

    -- Monad
    instance Class (Applicative f) (Monad f) where cls :: Monad f :- Applicative f
    cls = (Monad f => Dict (Applicative f)) -> Monad f :- Applicative f
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Applicative f)
    Monad f => Dict (Applicative f)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monad [] where ins :: (() :: Constraint) :- Monad []
    ins = ((() :: Constraint) => Dict (Monad []))
    -> (() :: Constraint) :- Monad []
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monad [])
    (() :: Constraint) => Dict (Monad [])
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monad ((->) a) where ins :: (() :: Constraint) :- Monad ((->) a)
    ins = ((() :: Constraint) => Dict (Monad ((->) a)))
    -> (() :: Constraint) :- Monad ((->) a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monad ((->) a))
    (() :: Constraint) => Dict (Monad ((->) a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monad (Either a) where ins :: (() :: Constraint) :- Monad (Either a)
    ins = ((() :: Constraint) => Dict (Monad (Either a)))
    -> (() :: Constraint) :- Monad (Either a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monad (Either a))
    (() :: Constraint) => Dict (Monad (Either a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monad IO where ins :: (() :: Constraint) :- Monad IO
    ins = ((() :: Constraint) => Dict (Monad IO))
    -> (() :: Constraint) :- Monad IO
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monad IO)
    (() :: Constraint) => Dict (Monad IO)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> Monad Identity where ins :: (() :: Constraint) :- Monad Identity
    ins = ((() :: Constraint) => Dict (Monad Identity))
    -> (() :: Constraint) :- Monad Identity
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monad Identity)
    (() :: Constraint) => Dict (Monad Identity)
    forall (c :: Constraint). c => Dict c
    Dict

    -- MonadPlus
    instance Class (Monad f, Alternative f) (MonadPlus f) where cls :: MonadPlus f :- (Monad f, Alternative f)
    cls = (MonadPlus f => Dict (Monad f, Alternative f))
    -> MonadPlus f :- (Monad f, Alternative f)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monad f, Alternative f)
    MonadPlus f => Dict (Monad f, Alternative f)
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> MonadPlus [] where ins :: (() :: Constraint) :- MonadPlus []
    ins = ((() :: Constraint) => Dict (MonadPlus []))
    -> (() :: Constraint) :- MonadPlus []
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (MonadPlus [])
    (() :: Constraint) => Dict (MonadPlus [])
    forall (c :: Constraint). c => Dict c
    Dict
    instance () :=> MonadPlus Maybe where ins :: (() :: Constraint) :- MonadPlus Maybe
    ins = ((() :: Constraint) => Dict (MonadPlus Maybe))
    -> (() :: Constraint) :- MonadPlus Maybe
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (MonadPlus Maybe)
    (() :: Constraint) => Dict (MonadPlus Maybe)
    forall (c :: Constraint). c => Dict c
    Dict

    --------------------------------------------------------------------------------
    -- UndecidableInstances
    --------------------------------------------------------------------------------

    instance a :=> Enum (Dict a) where ins :: a :- Enum (Dict a)
    ins = (a => Dict (Enum (Dict a))) -> a :- Enum (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Enum (Dict a))
    a => Dict (Enum (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance a => Enum (Dict a) where
      toEnum :: Int -> Dict a
    toEnum Int
    _ = Dict a
    forall (c :: Constraint). c => Dict c
    Dict
      fromEnum :: Dict a -> Int
    fromEnum Dict a
    Dict = Int
    0

    instance a :=> Bounded (Dict a) where ins :: a :- Bounded (Dict a)
    ins = (a => Dict (Bounded (Dict a))) -> a :- Bounded (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Bounded (Dict a))
    a => Dict (Bounded (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance a => Bounded (Dict a) where
      minBound :: Dict a
    minBound = Dict a
    forall (c :: Constraint). c => Dict c
    Dict
      maxBound :: Dict a
    maxBound = Dict a
    forall (c :: Constraint). c => Dict c
    Dict

    instance a :=> Read (Dict a) where ins :: a :- Read (Dict a)
    ins = (a => Dict (Read (Dict a))) -> a :- Read (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Read (Dict a))
    a => Dict (Read (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    deriving instance a => Read (Dict a)

    instance () :=> Semigroup (Dict a) where ins :: (() :: Constraint) :- Semigroup (Dict a)
    ins = ((() :: Constraint) => Dict (Semigroup (Dict a)))
    -> (() :: Constraint) :- Semigroup (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Semigroup (Dict a))
    (() :: Constraint) => Dict (Semigroup (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance Semigroup (Dict a) where
      Dict a
    Dict <> :: Dict a -> Dict a -> Dict a
    <> Dict a
    Dict = Dict a
    forall (c :: Constraint). c => Dict c
    Dict

    instance a :=> Monoid (Dict a) where ins :: a :- Monoid (Dict a)
    ins = (a => Dict (Monoid (Dict a))) -> a :- Monoid (Dict a)
    forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
    Sub Dict (Monoid (Dict a))
    a => Dict (Monoid (Dict a))
    forall (c :: Constraint). c => Dict c
    Dict
    instance a => Monoid (Dict a) where
      mempty :: Dict a
    mempty = Dict a
    forall (c :: Constraint). c => Dict c
    Dict