{-# LANGUAGE CPP #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PolyKinds #-}
#if !(MIN_VERSION_transformers(0,6,0))
{-# OPTIONS_GHC -fno-warn-deprecations #-}
#endif
module Data.Constraint.Lifting
  ( Lifting(..)
  , Lifting2(..)
  ) where

import Control.Applicative
import Control.Applicative.Backwards
import Control.Applicative.Lift
import Control.DeepSeq
import Control.Monad
import Control.Monad.Cont.Class
import Control.Monad.Error.Class
import Control.Monad.Fix
import Control.Monad.IO.Class
import Control.Monad.RWS.Class
import Control.Monad.Trans.Cont
import Control.Monad.Trans.Except
import Control.Monad.Trans.Identity
import Control.Monad.Trans.Maybe
import Control.Monad.Trans.Reader
import Control.Monad.Trans.RWS.Lazy as Lazy
import Control.Monad.Trans.RWS.Strict as Strict
import Control.Monad.Trans.State.Lazy as Lazy
import Control.Monad.Trans.State.Strict as Strict
import Control.Monad.Trans.Writer.Lazy as Lazy
import Control.Monad.Trans.Writer.Strict as Strict
#if !(MIN_VERSION_transformers(0,6,0))
import Control.Monad.Trans.Error
import Control.Monad.Trans.List
#endif
import Data.Binary
import Data.Complex
import Data.Constraint
#if __GLASGOW_HASKELL__ < 710
import Data.Foldable
#endif
import Data.Functor.Classes
import Data.Functor.Compose as Functor
import Data.Functor.Identity
import Data.Functor.Product as Functor
import Data.Functor.Reverse as Functor
import Data.Functor.Sum as Functor
import Data.Hashable
#if __GLASGOW_HASKELL__ < 710
import Data.Monoid
#endif
import Data.Ratio
#if !(MIN_VERSION_base(4,11,0))
import Data.Semigroup
#endif
#if __GLASGOW_HASKELL__ < 710
import Data.Traversable
#endif
import GHC.Arr

class Lifting p f where
  lifting :: p a :- p (f a)

instance Lifting Eq [] where lifting :: Eq a :- Eq [a]
lifting = (Eq a => Dict (Eq [a])) -> Eq a :- Eq [a]
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq [a])
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord [] where lifting :: Ord a :- Ord [a]
lifting = (Ord a => Dict (Ord [a])) -> Ord a :- Ord [a]
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord [a])
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show [] where lifting :: Show a :- Show [a]
lifting = (Show a => Dict (Show [a])) -> Show a :- Show [a]
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show [a])
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read [] where lifting :: Read a :- Read [a]
lifting = (Read a => Dict (Read [a])) -> Read a :- Read [a]
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read [a])
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Hashable [] where lifting :: Hashable a :- Hashable [a]
lifting = (Hashable a => Dict (Hashable [a])) -> Hashable a :- Hashable [a]
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Hashable a => Dict (Hashable [a])
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Binary [] where lifting :: Binary a :- Binary [a]
lifting = (Binary a => Dict (Binary [a])) -> Binary a :- Binary [a]
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Binary a => Dict (Binary [a])
forall (a :: Constraint). a => Dict a
Dict
instance Lifting NFData [] where lifting :: NFData a :- NFData [a]
lifting = (NFData a => Dict (NFData [a])) -> NFData a :- NFData [a]
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub NFData a => Dict (NFData [a])
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Eq Maybe where lifting :: Eq a :- Eq (Maybe a)
lifting = (Eq a => Dict (Eq (Maybe a))) -> Eq a :- Eq (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord Maybe where lifting :: Ord a :- Ord (Maybe a)
lifting = (Ord a => Dict (Ord (Maybe a))) -> Ord a :- Ord (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show Maybe where lifting :: Show a :- Show (Maybe a)
lifting = (Show a => Dict (Show (Maybe a))) -> Show a :- Show (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read Maybe where lifting :: Read a :- Read (Maybe a)
lifting = (Read a => Dict (Read (Maybe a))) -> Read a :- Read (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Hashable Maybe where lifting :: Hashable a :- Hashable (Maybe a)
lifting = (Hashable a => Dict (Hashable (Maybe a)))
-> Hashable a :- Hashable (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Hashable a => Dict (Hashable (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Binary Maybe where lifting :: Binary a :- Binary (Maybe a)
lifting = (Binary a => Dict (Binary (Maybe a)))
-> Binary a :- Binary (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Binary a => Dict (Binary (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting NFData Maybe where lifting :: NFData a :- NFData (Maybe a)
lifting = (NFData a => Dict (NFData (Maybe a)))
-> NFData a :- NFData (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub NFData a => Dict (NFData (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Semigroup Maybe where lifting :: Semigroup a :- Semigroup (Maybe a)
lifting = (Semigroup a => Dict (Semigroup (Maybe a)))
-> Semigroup a :- Semigroup (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Semigroup a => Dict (Semigroup (Maybe a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monoid Maybe where lifting :: Monoid a :- Monoid (Maybe a)
lifting = (Monoid a => Dict (Monoid (Maybe a)))
-> Monoid a :- Monoid (Maybe a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monoid a => Dict (Monoid (Maybe a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Eq Ratio where lifting :: Eq a :- Eq (Ratio a)
lifting = (Eq a => Dict (Eq (Ratio a))) -> Eq a :- Eq (Ratio a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Ratio a))
forall (a :: Constraint). a => Dict a
Dict
-- instance Lifting Show Ratio where lifting = Sub Dict -- requires 7.10

instance Lifting Eq Complex where lifting :: Eq a :- Eq (Complex a)
lifting = (Eq a => Dict (Eq (Complex a))) -> Eq a :- Eq (Complex a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Complex a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read Complex where lifting :: Read a :- Read (Complex a)
lifting = (Read a => Dict (Read (Complex a))) -> Read a :- Read (Complex a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Complex a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show Complex where lifting :: Show a :- Show (Complex a)
lifting = (Show a => Dict (Show (Complex a))) -> Show a :- Show (Complex a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Complex a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Semigroup ((->) a) where lifting :: Semigroup a :- Semigroup (a -> a)
lifting = (Semigroup a => Dict (Semigroup (a -> a)))
-> Semigroup a :- Semigroup (a -> a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Semigroup a => Dict (Semigroup (a -> a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monoid ((->) a) where lifting :: Monoid a :- Monoid (a -> a)
lifting = (Monoid a => Dict (Monoid (a -> a))) -> Monoid a :- Monoid (a -> a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monoid a => Dict (Monoid (a -> a))
forall (a :: Constraint). a => Dict a
Dict

instance Eq a => Lifting Eq (Either a) where lifting :: Eq a :- Eq (Either a a)
lifting = (Eq a => Dict (Eq (Either a a))) -> Eq a :- Eq (Either a a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Either a a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord a => Lifting Ord (Either a) where lifting :: Ord a :- Ord (Either a a)
lifting = (Ord a => Dict (Ord (Either a a))) -> Ord a :- Ord (Either a a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Either a a))
forall (a :: Constraint). a => Dict a
Dict
instance Show a => Lifting Show (Either a) where lifting :: Show a :- Show (Either a a)
lifting = (Show a => Dict (Show (Either a a))) -> Show a :- Show (Either a a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Either a a))
forall (a :: Constraint). a => Dict a
Dict
instance Read a => Lifting Read (Either a) where lifting :: Read a :- Read (Either a a)
lifting = (Read a => Dict (Read (Either a a))) -> Read a :- Read (Either a a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Either a a))
forall (a :: Constraint). a => Dict a
Dict
instance Hashable a => Lifting Hashable (Either a) where lifting :: Hashable a :- Hashable (Either a a)
lifting = (Hashable a => Dict (Hashable (Either a a)))
-> Hashable a :- Hashable (Either a a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Hashable a => Dict (Hashable (Either a a))
forall (a :: Constraint). a => Dict a
Dict
instance Binary a => Lifting Binary (Either a) where lifting :: Binary a :- Binary (Either a a)
lifting = (Binary a => Dict (Binary (Either a a)))
-> Binary a :- Binary (Either a a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Binary a => Dict (Binary (Either a a))
forall (a :: Constraint). a => Dict a
Dict
instance NFData a => Lifting NFData (Either a) where lifting :: NFData a :- NFData (Either a a)
lifting = (NFData a => Dict (NFData (Either a a)))
-> NFData a :- NFData (Either a a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub NFData a => Dict (NFData (Either a a))
forall (a :: Constraint). a => Dict a
Dict

instance Eq a => Lifting Eq ((,) a) where lifting :: Eq a :- Eq (a, a)
lifting = (Eq a => Dict (Eq (a, a))) -> Eq a :- Eq (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord a => Lifting Ord ((,) a) where lifting :: Ord a :- Ord (a, a)
lifting = (Ord a => Dict (Ord (a, a))) -> Ord a :- Ord (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Show a => Lifting Show ((,) a) where lifting :: Show a :- Show (a, a)
lifting = (Show a => Dict (Show (a, a))) -> Show a :- Show (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Read a => Lifting Read ((,) a) where lifting :: Read a :- Read (a, a)
lifting = (Read a => Dict (Read (a, a))) -> Read a :- Read (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Hashable a => Lifting Hashable ((,) a) where lifting :: Hashable a :- Hashable (a, a)
lifting = (Hashable a => Dict (Hashable (a, a)))
-> Hashable a :- Hashable (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Hashable a => Dict (Hashable (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Binary a => Lifting Binary ((,) a) where lifting :: Binary a :- Binary (a, a)
lifting = (Binary a => Dict (Binary (a, a))) -> Binary a :- Binary (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Binary a => Dict (Binary (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance NFData a => Lifting NFData ((,) a) where lifting :: NFData a :- NFData (a, a)
lifting = (NFData a => Dict (NFData (a, a))) -> NFData a :- NFData (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub NFData a => Dict (NFData (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Semigroup a => Lifting Semigroup ((,) a) where lifting :: Semigroup a :- Semigroup (a, a)
lifting = (Semigroup a => Dict (Semigroup (a, a)))
-> Semigroup a :- Semigroup (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Semigroup a => Dict (Semigroup (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid a => Lifting Monoid ((,) a) where lifting :: Monoid a :- Monoid (a, a)
lifting = (Monoid a => Dict (Monoid (a, a))) -> Monoid a :- Monoid (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monoid a => Dict (Monoid (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Bounded a => Lifting Bounded ((,) a) where lifting :: Bounded a :- Bounded (a, a)
lifting = (Bounded a => Dict (Bounded (a, a))) -> Bounded a :- Bounded (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Bounded a => Dict (Bounded (a, a))
forall (a :: Constraint). a => Dict a
Dict
instance Ix a => Lifting Ix ((,) a) where lifting :: Ix a :- Ix (a, a)
lifting = (Ix a => Dict (Ix (a, a))) -> Ix a :- Ix (a, a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ix a => Dict (Ix (a, a))
forall (a :: Constraint). a => Dict a
Dict

instance Functor f => Lifting Functor (Compose f) where lifting :: Functor a :- Functor (Compose f a)
lifting = (Functor a => Dict (Functor (Compose f a)))
-> Functor a :- Functor (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance Foldable f => Lifting Foldable (Compose f) where lifting :: Foldable a :- Foldable (Compose f a)
lifting = (Foldable a => Dict (Foldable (Compose f a)))
-> Foldable a :- Foldable (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance Traversable f => Lifting Traversable (Compose f) where lifting :: Traversable a :- Traversable (Compose f a)
lifting = (Traversable a => Dict (Traversable (Compose f a)))
-> Traversable a :- Traversable (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance Applicative f => Lifting Applicative (Compose f) where lifting :: Applicative a :- Applicative (Compose f a)
lifting = (Applicative a => Dict (Applicative (Compose f a)))
-> Applicative a :- Applicative (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance Alternative f => Lifting Alternative (Compose f) where lifting :: Alternative a :- Alternative (Compose f a)
lifting = (Alternative a => Dict (Alternative (Compose f a)))
-> Alternative a :- Alternative (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (Compose f a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained

#if MIN_VERSION_transformers(0,5,0)
instance Show1 f => Lifting Show1 (Compose f) where lifting :: Show1 a :- Show1 (Compose f a)
lifting = (Show1 a => Dict (Show1 (Compose f a)))
-> Show1 a :- Show1 (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 f => Lifting Eq1 (Compose f) where lifting :: Eq1 a :- Eq1 (Compose f a)
lifting = (Eq1 a => Dict (Eq1 (Compose f a))) -> Eq1 a :- Eq1 (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 f => Lifting Ord1 (Compose f) where lifting :: Ord1 a :- Ord1 (Compose f a)
lifting = (Ord1 a => Dict (Ord1 (Compose f a)))
-> Ord1 a :- Ord1 (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 f => Lifting Read1 (Compose f) where lifting :: Read1 a :- Read1 (Compose f a)
lifting = (Read1 a => Dict (Read1 (Compose f a)))
-> Read1 a :- Read1 (Compose f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (Compose f a))
forall (a :: Constraint). a => Dict a
Dict
instance (Eq1 f, Eq1 g) => Lifting Eq (Compose f g) where lifting :: Eq a :- Eq (Compose f g a)
lifting = (Eq a => Dict (Eq (Compose f g a))) -> Eq a :- Eq (Compose f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Compose f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Ord1 f, Ord1 g) => Lifting Ord (Compose f g) where lifting :: Ord a :- Ord (Compose f g a)
lifting = (Ord a => Dict (Ord (Compose f g a)))
-> Ord a :- Ord (Compose f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Compose f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Read1 f, Read1 g) => Lifting Read (Compose f g) where lifting :: Read a :- Read (Compose f g a)
lifting = (Read a => Dict (Read (Compose f g a)))
-> Read a :- Read (Compose f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Compose f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Show1 f, Show1 g) => Lifting Show (Compose f g) where lifting :: Show a :- Show (Compose f g a)
lifting = (Show a => Dict (Show (Compose f g a)))
-> Show a :- Show (Compose f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Compose f g a))
forall (a :: Constraint). a => Dict a
Dict
#else
instance (Functor f, Show1 f) => Lifting Show1 (Compose f) where lifting = Sub Dict
instance (Functor f, Eq1 f) => Lifting Eq1 (Compose f) where lifting = Sub Dict
instance (Functor f, Ord1 f) => Lifting Ord1 (Compose f) where lifting = Sub Dict
instance (Functor f, Read1 f) => Lifting Read1 (Compose f) where lifting = Sub Dict
instance (Functor f, Eq1 f, Eq1 g) => Lifting Eq (Compose f g) where lifting = Sub Dict
instance (Functor f, Ord1 f, Ord1 g) => Lifting Ord (Compose f g) where lifting = Sub Dict
instance (Functor f, Read1 f, Read1 g) => Lifting Read (Compose f g) where lifting = Sub Dict
instance (Functor f, Show1 f, Show1 g) => Lifting Show (Compose f g) where lifting = Sub Dict
#endif

instance Functor f => Lifting Functor (Functor.Product f) where lifting :: Functor a :- Functor (Product f a)
lifting = (Functor a => Dict (Functor (Product f a)))
-> Functor a :- Functor (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Foldable f => Lifting Foldable (Functor.Product f) where lifting :: Foldable a :- Foldable (Product f a)
lifting = (Foldable a => Dict (Foldable (Product f a)))
-> Foldable a :- Foldable (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Traversable f => Lifting Traversable (Functor.Product f) where lifting :: Traversable a :- Traversable (Product f a)
lifting = (Traversable a => Dict (Traversable (Product f a)))
-> Traversable a :- Traversable (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Applicative f => Lifting Applicative (Functor.Product f) where lifting :: Applicative a :- Applicative (Product f a)
lifting = (Applicative a => Dict (Applicative (Product f a)))
-> Applicative a :- Applicative (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Alternative f => Lifting Alternative (Functor.Product f) where lifting :: Alternative a :- Alternative (Product f a)
lifting = (Alternative a => Dict (Alternative (Product f a)))
-> Alternative a :- Alternative (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Monad f => Lifting Monad (Functor.Product f) where lifting :: Monad a :- Monad (Product f a)
lifting = (Monad a => Dict (Monad (Product f a)))
-> Monad a :- Monad (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance MonadFix f => Lifting MonadFix (Functor.Product f) where lifting :: MonadFix a :- MonadFix (Product f a)
lifting = (MonadFix a => Dict (MonadFix (Product f a)))
-> MonadFix a :- MonadFix (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance MonadPlus f => Lifting MonadPlus (Functor.Product f) where lifting :: MonadPlus a :- MonadPlus (Product f a)
lifting = (MonadPlus a => Dict (MonadPlus (Product f a)))
-> MonadPlus a :- MonadPlus (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 f => Lifting Show1 (Functor.Product f) where lifting :: Show1 a :- Show1 (Product f a)
lifting = (Show1 a => Dict (Show1 (Product f a)))
-> Show1 a :- Show1 (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 f => Lifting Eq1 (Functor.Product f) where lifting :: Eq1 a :- Eq1 (Product f a)
lifting = (Eq1 a => Dict (Eq1 (Product f a))) -> Eq1 a :- Eq1 (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 f => Lifting Ord1 (Functor.Product f) where lifting :: Ord1 a :- Ord1 (Product f a)
lifting = (Ord1 a => Dict (Ord1 (Product f a)))
-> Ord1 a :- Ord1 (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 f => Lifting Read1 (Functor.Product f) where lifting :: Read1 a :- Read1 (Product f a)
lifting = (Read1 a => Dict (Read1 (Product f a)))
-> Read1 a :- Read1 (Product f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (Product f a))
forall (a :: Constraint). a => Dict a
Dict
instance (Eq1 f, Eq1 g) => Lifting Eq (Functor.Product f g) where lifting :: Eq a :- Eq (Product f g a)
lifting = (Eq a => Dict (Eq (Product f g a))) -> Eq a :- Eq (Product f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Product f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Ord1 f, Ord1 g) => Lifting Ord (Functor.Product f g) where lifting :: Ord a :- Ord (Product f g a)
lifting = (Ord a => Dict (Ord (Product f g a)))
-> Ord a :- Ord (Product f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Product f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Read1 f, Read1 g) => Lifting Read (Functor.Product f g) where lifting :: Read a :- Read (Product f g a)
lifting = (Read a => Dict (Read (Product f g a)))
-> Read a :- Read (Product f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Product f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Show1 f, Show1 g) => Lifting Show (Functor.Product f g) where lifting :: Show a :- Show (Product f g a)
lifting = (Show a => Dict (Show (Product f g a)))
-> Show a :- Show (Product f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Product f g a))
forall (a :: Constraint). a => Dict a
Dict

instance Functor f => Lifting Functor (Functor.Sum f) where lifting :: Functor a :- Functor (Sum f a)
lifting = (Functor a => Dict (Functor (Sum f a)))
-> Functor a :- Functor (Sum f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (Sum f a))
forall (a :: Constraint). a => Dict a
Dict
instance Foldable f => Lifting Foldable (Functor.Sum f) where lifting :: Foldable a :- Foldable (Sum f a)
lifting = (Foldable a => Dict (Foldable (Sum f a)))
-> Foldable a :- Foldable (Sum f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (Sum f a))
forall (a :: Constraint). a => Dict a
Dict
instance Traversable f => Lifting Traversable (Functor.Sum f) where lifting :: Traversable a :- Traversable (Sum f a)
lifting = (Traversable a => Dict (Traversable (Sum f a)))
-> Traversable a :- Traversable (Sum f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (Sum f a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 f => Lifting Show1 (Functor.Sum f) where lifting :: Show1 a :- Show1 (Sum f a)
lifting = (Show1 a => Dict (Show1 (Sum f a))) -> Show1 a :- Show1 (Sum f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (Sum f a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 f => Lifting Eq1 (Functor.Sum f) where lifting :: Eq1 a :- Eq1 (Sum f a)
lifting = (Eq1 a => Dict (Eq1 (Sum f a))) -> Eq1 a :- Eq1 (Sum f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (Sum f a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 f => Lifting Ord1 (Functor.Sum f) where lifting :: Ord1 a :- Ord1 (Sum f a)
lifting = (Ord1 a => Dict (Ord1 (Sum f a))) -> Ord1 a :- Ord1 (Sum f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (Sum f a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 f => Lifting Read1 (Functor.Sum f) where lifting :: Read1 a :- Read1 (Sum f a)
lifting = (Read1 a => Dict (Read1 (Sum f a))) -> Read1 a :- Read1 (Sum f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (Sum f a))
forall (a :: Constraint). a => Dict a
Dict
instance (Eq1 f, Eq1 g) => Lifting Eq (Functor.Sum f g) where lifting :: Eq a :- Eq (Sum f g a)
lifting = (Eq a => Dict (Eq (Sum f g a))) -> Eq a :- Eq (Sum f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Sum f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Ord1 f, Ord1 g) => Lifting Ord (Functor.Sum f g) where lifting :: Ord a :- Ord (Sum f g a)
lifting = (Ord a => Dict (Ord (Sum f g a))) -> Ord a :- Ord (Sum f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Sum f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Read1 f, Read1 g) => Lifting Read (Functor.Sum f g) where lifting :: Read a :- Read (Sum f g a)
lifting = (Read a => Dict (Read (Sum f g a))) -> Read a :- Read (Sum f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Sum f g a))
forall (a :: Constraint). a => Dict a
Dict
instance (Show1 f, Show1 g) => Lifting Show (Functor.Sum f g) where lifting :: Show a :- Show (Sum f g a)
lifting = (Show a => Dict (Show (Sum f g a))) -> Show a :- Show (Sum f g a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Sum f g a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (Strict.StateT s) where lifting :: Functor a :- Functor (StateT s a)
lifting = (Functor a => Dict (Functor (StateT s a)))
-> Functor a :- Functor (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monad (Strict.StateT s) where lifting :: Monad a :- Monad (StateT s a)
lifting = (Monad a => Dict (Monad (StateT s a)))
-> Monad a :- Monad (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadFix (Strict.StateT s) where lifting :: MonadFix a :- MonadFix (StateT s a)
lifting = (MonadFix a => Dict (MonadFix (StateT s a)))
-> MonadFix a :- MonadFix (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadIO (Strict.StateT s) where lifting :: MonadIO a :- MonadIO (StateT s a)
lifting = (MonadIO a => Dict (MonadIO (StateT s a)))
-> MonadIO a :- MonadIO (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadPlus (Strict.StateT s) where lifting :: MonadPlus a :- MonadPlus (StateT s a)
lifting = (MonadPlus a => Dict (MonadPlus (StateT s a)))
-> MonadPlus a :- MonadPlus (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (StateT s a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (Lazy.StateT s) where lifting :: Functor a :- Functor (StateT s a)
lifting = (Functor a => Dict (Functor (StateT s a)))
-> Functor a :- Functor (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monad (Lazy.StateT s) where lifting :: Monad a :- Monad (StateT s a)
lifting = (Monad a => Dict (Monad (StateT s a)))
-> Monad a :- Monad (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadFix (Lazy.StateT s) where lifting :: MonadFix a :- MonadFix (StateT s a)
lifting = (MonadFix a => Dict (MonadFix (StateT s a)))
-> MonadFix a :- MonadFix (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadIO (Lazy.StateT s) where lifting :: MonadIO a :- MonadIO (StateT s a)
lifting = (MonadIO a => Dict (MonadIO (StateT s a)))
-> MonadIO a :- MonadIO (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadPlus (Lazy.StateT s) where lifting :: MonadPlus a :- MonadPlus (StateT s a)
lifting = (MonadPlus a => Dict (MonadPlus (StateT s a)))
-> MonadPlus a :- MonadPlus (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (StateT s a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (Lazy.RWST r w s) where lifting :: Functor a :- Functor (RWST r w s a)
lifting = (Functor a => Dict (Functor (RWST r w s a)))
-> Functor a :- Functor (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Monad (Lazy.RWST r w s) where lifting :: Monad a :- Monad (RWST r w s a)
lifting = (Monad a => Dict (Monad (RWST r w s a)))
-> Monad a :- Monad (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadFix (Lazy.RWST r w s) where lifting :: MonadFix a :- MonadFix (RWST r w s a)
lifting = (MonadFix a => Dict (MonadFix (RWST r w s a)))
-> MonadFix a :- MonadFix (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadPlus (Lazy.RWST r w s) where lifting :: MonadPlus a :- MonadPlus (RWST r w s a)
lifting = (MonadPlus a => Dict (MonadPlus (RWST r w s a)))
-> MonadPlus a :- MonadPlus (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadIO (Lazy.RWST r w s) where lifting :: MonadIO a :- MonadIO (RWST r w s a)
lifting = (MonadIO a => Dict (MonadIO (RWST r w s a)))
-> MonadIO a :- MonadIO (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (Strict.RWST r w s) where lifting :: Functor a :- Functor (RWST r w s a)
lifting = (Functor a => Dict (Functor (RWST r w s a)))
-> Functor a :- Functor (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Monad (Strict.RWST r w s) where lifting :: Monad a :- Monad (RWST r w s a)
lifting = (Monad a => Dict (Monad (RWST r w s a)))
-> Monad a :- Monad (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadFix (Strict.RWST r w s) where lifting :: MonadFix a :- MonadFix (RWST r w s a)
lifting = (MonadFix a => Dict (MonadFix (RWST r w s a)))
-> MonadFix a :- MonadFix (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadPlus (Strict.RWST r w s) where lifting :: MonadPlus a :- MonadPlus (RWST r w s a)
lifting = (MonadPlus a => Dict (MonadPlus (RWST r w s a)))
-> MonadPlus a :- MonadPlus (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadIO (Strict.RWST r w s) where lifting :: MonadIO a :- MonadIO (RWST r w s a)
lifting = (MonadIO a => Dict (MonadIO (RWST r w s a)))
-> MonadIO a :- MonadIO (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (ReaderT e) where lifting :: Functor a :- Functor (ReaderT e a)
lifting = (Functor a => Dict (Functor (ReaderT e a)))
-> Functor a :- Functor (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Applicative (ReaderT e) where lifting :: Applicative a :- Applicative (ReaderT e a)
lifting = (Applicative a => Dict (Applicative (ReaderT e a)))
-> Applicative a :- Applicative (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Alternative (ReaderT e) where lifting :: Alternative a :- Alternative (ReaderT e a)
lifting = (Alternative a => Dict (Alternative (ReaderT e a)))
-> Alternative a :- Alternative (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monad (ReaderT e) where lifting :: Monad a :- Monad (ReaderT e a)
lifting = (Monad a => Dict (Monad (ReaderT e a)))
-> Monad a :- Monad (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadPlus (ReaderT e) where lifting :: MonadPlus a :- MonadPlus (ReaderT e a)
lifting = (MonadPlus a => Dict (MonadPlus (ReaderT e a)))
-> MonadPlus a :- MonadPlus (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadFix (ReaderT e) where lifting :: MonadFix a :- MonadFix (ReaderT e a)
lifting = (MonadFix a => Dict (MonadFix (ReaderT e a)))
-> MonadFix a :- MonadFix (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadIO (ReaderT e) where lifting :: MonadIO a :- MonadIO (ReaderT e a)
lifting = (MonadIO a => Dict (MonadIO (ReaderT e a)))
-> MonadIO a :- MonadIO (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (ExceptT e) where lifting :: Functor a :- Functor (ExceptT e a)
lifting = (Functor a => Dict (Functor (ExceptT e a)))
-> Functor a :- Functor (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable (ExceptT e) where lifting :: Foldable a :- Foldable (ExceptT e a)
lifting = (Foldable a => Dict (Foldable (ExceptT e a)))
-> Foldable a :- Foldable (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable (ExceptT e) where lifting :: Traversable a :- Traversable (ExceptT e a)
lifting = (Traversable a => Dict (Traversable (ExceptT e a)))
-> Traversable a :- Traversable (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monad (ExceptT e) where lifting :: Monad a :- Monad (ExceptT e a)
lifting = (Monad a => Dict (Monad (ExceptT e a)))
-> Monad a :- Monad (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadFix (ExceptT e) where lifting :: MonadFix a :- MonadFix (ExceptT e a)
lifting = (MonadFix a => Dict (MonadFix (ExceptT e a)))
-> MonadFix a :- MonadFix (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid e => Lifting MonadPlus (ExceptT e) where lifting :: MonadPlus a :- MonadPlus (ExceptT e a)
lifting = (MonadPlus a => Dict (MonadPlus (ExceptT e a)))
-> MonadPlus a :- MonadPlus (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained!
instance Lifting MonadIO (ExceptT e) where lifting :: MonadIO a :- MonadIO (ExceptT e a)
lifting = (MonadIO a => Dict (MonadIO (ExceptT e a)))
-> MonadIO a :- MonadIO (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Show e => Lifting Show1 (ExceptT e) where lifting :: Show1 a :- Show1 (ExceptT e a)
lifting = (Show1 a => Dict (Show1 (ExceptT e a)))
-> Show1 a :- Show1 (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq e => Lifting Eq1 (ExceptT e) where lifting :: Eq1 a :- Eq1 (ExceptT e a)
lifting = (Eq1 a => Dict (Eq1 (ExceptT e a))) -> Eq1 a :- Eq1 (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord e => Lifting Ord1 (ExceptT e) where lifting :: Ord1 a :- Ord1 (ExceptT e a)
lifting = (Ord1 a => Dict (Ord1 (ExceptT e a)))
-> Ord1 a :- Ord1 (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Read e => Lifting Read1 (ExceptT e) where lifting :: Read1 a :- Read1 (ExceptT e a)
lifting = (Read1 a => Dict (Read1 (ExceptT e a)))
-> Read1 a :- Read1 (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance (Show e, Show1 m) => Lifting Show (ExceptT e m) where lifting :: Show a :- Show (ExceptT e m a)
lifting = (Show a => Dict (Show (ExceptT e m a)))
-> Show a :- Show (ExceptT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (ExceptT e m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Eq e, Eq1 m) => Lifting Eq (ExceptT e m) where lifting :: Eq a :- Eq (ExceptT e m a)
lifting = (Eq a => Dict (Eq (ExceptT e m a))) -> Eq a :- Eq (ExceptT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (ExceptT e m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Ord e, Ord1 m) => Lifting Ord (ExceptT e m) where lifting :: Ord a :- Ord (ExceptT e m a)
lifting = (Ord a => Dict (Ord (ExceptT e m a)))
-> Ord a :- Ord (ExceptT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (ExceptT e m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Read e, Read1 m) => Lifting Read (ExceptT e m) where lifting :: Read a :- Read (ExceptT e m a)
lifting = (Read a => Dict (Read (ExceptT e m a)))
-> Read a :- Read (ExceptT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (ExceptT e m a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (Strict.WriterT w) where lifting :: Functor a :- Functor (WriterT w a)
lifting = (Functor a => Dict (Functor (WriterT w a)))
-> Functor a :- Functor (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Applicative (Strict.WriterT w) where lifting :: Applicative a :- Applicative (WriterT w a)
lifting = (Applicative a => Dict (Applicative (WriterT w a)))
-> Applicative a :- Applicative (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Alternative (Strict.WriterT w) where lifting :: Alternative a :- Alternative (WriterT w a)
lifting = (Alternative a => Dict (Alternative (WriterT w a)))
-> Alternative a :- Alternative (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Monad (Strict.WriterT w) where lifting :: Monad a :- Monad (WriterT w a)
lifting = (Monad a => Dict (Monad (WriterT w a)))
-> Monad a :- Monad (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadFix (Strict.WriterT w) where lifting :: MonadFix a :- MonadFix (WriterT w a)
lifting = (MonadFix a => Dict (MonadFix (WriterT w a)))
-> MonadFix a :- MonadFix (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadPlus (Strict.WriterT w) where lifting :: MonadPlus a :- MonadPlus (WriterT w a)
lifting = (MonadPlus a => Dict (MonadPlus (WriterT w a)))
-> MonadPlus a :- MonadPlus (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable (Strict.WriterT w) where lifting :: Foldable a :- Foldable (WriterT w a)
lifting = (Foldable a => Dict (Foldable (WriterT w a)))
-> Foldable a :- Foldable (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable (Strict.WriterT w) where lifting :: Traversable a :- Traversable (WriterT w a)
lifting = (Traversable a => Dict (Traversable (WriterT w a)))
-> Traversable a :- Traversable (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadIO (Strict.WriterT w) where lifting :: MonadIO a :- MonadIO (WriterT w a)
lifting = (MonadIO a => Dict (MonadIO (WriterT w a)))
-> MonadIO a :- MonadIO (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Show w => Lifting Show1 (Strict.WriterT w) where lifting :: Show1 a :- Show1 (WriterT w a)
lifting = (Show1 a => Dict (Show1 (WriterT w a)))
-> Show1 a :- Show1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq w => Lifting Eq1 (Strict.WriterT w) where lifting :: Eq1 a :- Eq1 (WriterT w a)
lifting = (Eq1 a => Dict (Eq1 (WriterT w a))) -> Eq1 a :- Eq1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord w => Lifting Ord1 (Strict.WriterT w) where lifting :: Ord1 a :- Ord1 (WriterT w a)
lifting = (Ord1 a => Dict (Ord1 (WriterT w a)))
-> Ord1 a :- Ord1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Read w => Lifting Read1 (Strict.WriterT w) where lifting :: Read1 a :- Read1 (WriterT w a)
lifting = (Read1 a => Dict (Read1 (WriterT w a)))
-> Read1 a :- Read1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance (Show w, Show1 m) => Lifting Show (Strict.WriterT w m) where lifting :: Show a :- Show (WriterT w m a)
lifting = (Show a => Dict (Show (WriterT w m a)))
-> Show a :- Show (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Eq w, Eq1 m) => Lifting Eq (Strict.WriterT w m) where lifting :: Eq a :- Eq (WriterT w m a)
lifting = (Eq a => Dict (Eq (WriterT w m a))) -> Eq a :- Eq (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Ord w, Ord1 m) => Lifting Ord (Strict.WriterT w m) where lifting :: Ord a :- Ord (WriterT w m a)
lifting = (Ord a => Dict (Ord (WriterT w m a)))
-> Ord a :- Ord (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Read w, Read1 m) => Lifting Read (Strict.WriterT w m) where lifting :: Read a :- Read (WriterT w m a)
lifting = (Read a => Dict (Read (WriterT w m a)))
-> Read a :- Read (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (Lazy.WriterT w) where lifting :: Functor a :- Functor (WriterT w a)
lifting = (Functor a => Dict (Functor (WriterT w a)))
-> Functor a :- Functor (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Applicative (Lazy.WriterT w) where lifting :: Applicative a :- Applicative (WriterT w a)
lifting = (Applicative a => Dict (Applicative (WriterT w a)))
-> Applicative a :- Applicative (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Alternative (Lazy.WriterT w) where lifting :: Alternative a :- Alternative (WriterT w a)
lifting = (Alternative a => Dict (Alternative (WriterT w a)))
-> Alternative a :- Alternative (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting Monad (Lazy.WriterT w) where lifting :: Monad a :- Monad (WriterT w a)
lifting = (Monad a => Dict (Monad (WriterT w a)))
-> Monad a :- Monad (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadFix (Lazy.WriterT w) where lifting :: MonadFix a :- MonadFix (WriterT w a)
lifting = (MonadFix a => Dict (MonadFix (WriterT w a)))
-> MonadFix a :- MonadFix (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadPlus (Lazy.WriterT w) where lifting :: MonadPlus a :- MonadPlus (WriterT w a)
lifting = (MonadPlus a => Dict (MonadPlus (WriterT w a)))
-> MonadPlus a :- MonadPlus (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable (Lazy.WriterT w) where lifting :: Foldable a :- Foldable (WriterT w a)
lifting = (Foldable a => Dict (Foldable (WriterT w a)))
-> Foldable a :- Foldable (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable (Lazy.WriterT w) where lifting :: Traversable a :- Traversable (WriterT w a)
lifting = (Traversable a => Dict (Traversable (WriterT w a)))
-> Traversable a :- Traversable (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadIO (Lazy.WriterT w) where lifting :: MonadIO a :- MonadIO (WriterT w a)
lifting = (MonadIO a => Dict (MonadIO (WriterT w a)))
-> MonadIO a :- MonadIO (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Show w => Lifting Show1 (Lazy.WriterT w) where lifting :: Show1 a :- Show1 (WriterT w a)
lifting = (Show1 a => Dict (Show1 (WriterT w a)))
-> Show1 a :- Show1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq w => Lifting Eq1 (Lazy.WriterT w) where lifting :: Eq1 a :- Eq1 (WriterT w a)
lifting = (Eq1 a => Dict (Eq1 (WriterT w a))) -> Eq1 a :- Eq1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord w => Lifting Ord1 (Lazy.WriterT w) where lifting :: Ord1 a :- Ord1 (WriterT w a)
lifting = (Ord1 a => Dict (Ord1 (WriterT w a)))
-> Ord1 a :- Ord1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Read w => Lifting Read1 (Lazy.WriterT w) where lifting :: Read1 a :- Read1 (WriterT w a)
lifting = (Read1 a => Dict (Read1 (WriterT w a)))
-> Read1 a :- Read1 (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance (Show w, Show1 m) => Lifting Show (Lazy.WriterT w m) where lifting :: Show a :- Show (WriterT w m a)
lifting = (Show a => Dict (Show (WriterT w m a)))
-> Show a :- Show (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Eq w, Eq1 m) => Lifting Eq (Lazy.WriterT w m) where lifting :: Eq a :- Eq (WriterT w m a)
lifting = (Eq a => Dict (Eq (WriterT w m a))) -> Eq a :- Eq (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Ord w, Ord1 m) => Lifting Ord (Lazy.WriterT w m) where lifting :: Ord a :- Ord (WriterT w m a)
lifting = (Ord a => Dict (Ord (WriterT w m a)))
-> Ord a :- Ord (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Read w, Read1 m) => Lifting Read (Lazy.WriterT w m) where lifting :: Read a :- Read (WriterT w m a)
lifting = (Read a => Dict (Read (WriterT w m a)))
-> Read a :- Read (WriterT w m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (WriterT w m a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor (ContT r) where lifting :: Functor a :- Functor (ContT r a)
lifting = (Functor a => Dict (Functor (ContT r a)))
-> Functor a :- Functor (ContT r a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (ContT r a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained
instance Lifting Applicative (ContT r) where lifting :: Applicative a :- Applicative (ContT r a)
lifting = (Applicative a => Dict (Applicative (ContT r a)))
-> Applicative a :- Applicative (ContT r a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (ContT r a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained
instance Lifting Monad (ContT r) where lifting :: Monad a :- Monad (ContT r a)
lifting = (Monad a => Dict (Monad (ContT r a)))
-> Monad a :- Monad (ContT r a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (ContT r a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained
instance Lifting MonadIO (ContT r) where lifting :: MonadIO a :- MonadIO (ContT r a)
lifting = (MonadIO a => Dict (MonadIO (ContT r a)))
-> MonadIO a :- MonadIO (ContT r a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (ContT r a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor IdentityT where lifting :: Functor a :- Functor (IdentityT a)
lifting = (Functor a => Dict (Functor (IdentityT a)))
-> Functor a :- Functor (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Applicative IdentityT where lifting :: Applicative a :- Applicative (IdentityT a)
lifting = (Applicative a => Dict (Applicative (IdentityT a)))
-> Applicative a :- Applicative (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Alternative IdentityT where lifting :: Alternative a :- Alternative (IdentityT a)
lifting = (Alternative a => Dict (Alternative (IdentityT a)))
-> Alternative a :- Alternative (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monad IdentityT where lifting :: Monad a :- Monad (IdentityT a)
lifting = (Monad a => Dict (Monad (IdentityT a)))
-> Monad a :- Monad (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadPlus IdentityT where lifting :: MonadPlus a :- MonadPlus (IdentityT a)
lifting = (MonadPlus a => Dict (MonadPlus (IdentityT a)))
-> MonadPlus a :- MonadPlus (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadFix IdentityT where lifting :: MonadFix a :- MonadFix (IdentityT a)
lifting = (MonadFix a => Dict (MonadFix (IdentityT a)))
-> MonadFix a :- MonadFix (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable IdentityT where lifting :: Foldable a :- Foldable (IdentityT a)
lifting = (Foldable a => Dict (Foldable (IdentityT a)))
-> Foldable a :- Foldable (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable IdentityT where lifting :: Traversable a :- Traversable (IdentityT a)
lifting = (Traversable a => Dict (Traversable (IdentityT a)))
-> Traversable a :- Traversable (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadIO IdentityT where lifting :: MonadIO a :- MonadIO (IdentityT a)
lifting = (MonadIO a => Dict (MonadIO (IdentityT a)))
-> MonadIO a :- MonadIO (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show1 IdentityT where lifting :: Show1 a :- Show1 (IdentityT a)
lifting = (Show1 a => Dict (Show1 (IdentityT a)))
-> Show1 a :- Show1 (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read1 IdentityT where lifting :: Read1 a :- Read1 (IdentityT a)
lifting = (Read1 a => Dict (Read1 (IdentityT a)))
-> Read1 a :- Read1 (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord1 IdentityT where lifting :: Ord1 a :- Ord1 (IdentityT a)
lifting = (Ord1 a => Dict (Ord1 (IdentityT a)))
-> Ord1 a :- Ord1 (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Eq1 IdentityT where lifting :: Eq1 a :- Eq1 (IdentityT a)
lifting = (Eq1 a => Dict (Eq1 (IdentityT a))) -> Eq1 a :- Eq1 (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 m => Lifting Show (IdentityT m) where lifting :: Show a :- Show (IdentityT m a)
lifting = (Show a => Dict (Show (IdentityT m a)))
-> Show a :- Show (IdentityT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (IdentityT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 m => Lifting Read (IdentityT m) where lifting :: Read a :- Read (IdentityT m a)
lifting = (Read a => Dict (Read (IdentityT m a)))
-> Read a :- Read (IdentityT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (IdentityT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 m => Lifting Ord (IdentityT m) where lifting :: Ord a :- Ord (IdentityT m a)
lifting = (Ord a => Dict (Ord (IdentityT m a)))
-> Ord a :- Ord (IdentityT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (IdentityT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 m => Lifting Eq (IdentityT m) where lifting :: Eq a :- Eq (IdentityT m a)
lifting = (Eq a => Dict (Eq (IdentityT m a))) -> Eq a :- Eq (IdentityT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (IdentityT m a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor MaybeT where lifting :: Functor a :- Functor (MaybeT a)
lifting = (Functor a => Dict (Functor (MaybeT a)))
-> Functor a :- Functor (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Monad MaybeT where lifting :: Monad a :- Monad (MaybeT a)
lifting = (Monad a => Dict (Monad (MaybeT a))) -> Monad a :- Monad (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
-- instance Lifting MonadFix MaybeT where lifting = Sub Dict
instance Lifting MonadPlus MaybeT where lifting :: MonadPlus a :- MonadPlus (MaybeT a)
lifting = (MonadPlus a => Dict (MonadPlus (MaybeT a)))
-> MonadPlus a :- MonadPlus (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained
instance Lifting Foldable MaybeT where lifting :: Foldable a :- Foldable (MaybeT a)
lifting = (Foldable a => Dict (Foldable (MaybeT a)))
-> Foldable a :- Foldable (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable MaybeT where lifting :: Traversable a :- Traversable (MaybeT a)
lifting = (Traversable a => Dict (Traversable (MaybeT a)))
-> Traversable a :- Traversable (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadIO MaybeT where lifting :: MonadIO a :- MonadIO (MaybeT a)
lifting = (MonadIO a => Dict (MonadIO (MaybeT a)))
-> MonadIO a :- MonadIO (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show1 MaybeT where lifting :: Show1 a :- Show1 (MaybeT a)
lifting = (Show1 a => Dict (Show1 (MaybeT a))) -> Show1 a :- Show1 (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read1 MaybeT where lifting :: Read1 a :- Read1 (MaybeT a)
lifting = (Read1 a => Dict (Read1 (MaybeT a))) -> Read1 a :- Read1 (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord1 MaybeT where lifting :: Ord1 a :- Ord1 (MaybeT a)
lifting = (Ord1 a => Dict (Ord1 (MaybeT a))) -> Ord1 a :- Ord1 (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Eq1 MaybeT where lifting :: Eq1 a :- Eq1 (MaybeT a)
lifting = (Eq1 a => Dict (Eq1 (MaybeT a))) -> Eq1 a :- Eq1 (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 m => Lifting Show (MaybeT m) where lifting :: Show a :- Show (MaybeT m a)
lifting = (Show a => Dict (Show (MaybeT m a))) -> Show a :- Show (MaybeT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (MaybeT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 m => Lifting Read (MaybeT m) where lifting :: Read a :- Read (MaybeT m a)
lifting = (Read a => Dict (Read (MaybeT m a))) -> Read a :- Read (MaybeT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (MaybeT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 m => Lifting Ord (MaybeT m) where lifting :: Ord a :- Ord (MaybeT m a)
lifting = (Ord a => Dict (Ord (MaybeT m a))) -> Ord a :- Ord (MaybeT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (MaybeT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 m => Lifting Eq (MaybeT m) where lifting :: Eq a :- Eq (MaybeT m a)
lifting = (Eq a => Dict (Eq (MaybeT m a))) -> Eq a :- Eq (MaybeT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (MaybeT m a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor Reverse where lifting :: Functor a :- Functor (Reverse a)
lifting = (Functor a => Dict (Functor (Reverse a)))
-> Functor a :- Functor (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Applicative Reverse where lifting :: Applicative a :- Applicative (Reverse a)
lifting = (Applicative a => Dict (Applicative (Reverse a)))
-> Applicative a :- Applicative (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Alternative Reverse where lifting :: Alternative a :- Alternative (Reverse a)
lifting = (Alternative a => Dict (Alternative (Reverse a)))
-> Alternative a :- Alternative (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable Reverse where lifting :: Foldable a :- Foldable (Reverse a)
lifting = (Foldable a => Dict (Foldable (Reverse a)))
-> Foldable a :- Foldable (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable Reverse where lifting :: Traversable a :- Traversable (Reverse a)
lifting = (Traversable a => Dict (Traversable (Reverse a)))
-> Traversable a :- Traversable (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show1 Reverse where lifting :: Show1 a :- Show1 (Reverse a)
lifting = (Show1 a => Dict (Show1 (Reverse a)))
-> Show1 a :- Show1 (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read1 Reverse where lifting :: Read1 a :- Read1 (Reverse a)
lifting = (Read1 a => Dict (Read1 (Reverse a)))
-> Read1 a :- Read1 (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord1 Reverse where lifting :: Ord1 a :- Ord1 (Reverse a)
lifting = (Ord1 a => Dict (Ord1 (Reverse a))) -> Ord1 a :- Ord1 (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Eq1 Reverse where lifting :: Eq1 a :- Eq1 (Reverse a)
lifting = (Eq1 a => Dict (Eq1 (Reverse a))) -> Eq1 a :- Eq1 (Reverse a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (Reverse a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 f => Lifting Show (Reverse f) where lifting :: Show a :- Show (Reverse f a)
lifting = (Show a => Dict (Show (Reverse f a)))
-> Show a :- Show (Reverse f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Reverse f a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 f => Lifting Read (Reverse f) where lifting :: Read a :- Read (Reverse f a)
lifting = (Read a => Dict (Read (Reverse f a)))
-> Read a :- Read (Reverse f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Reverse f a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 f => Lifting Ord (Reverse f) where lifting :: Ord a :- Ord (Reverse f a)
lifting = (Ord a => Dict (Ord (Reverse f a))) -> Ord a :- Ord (Reverse f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Reverse f a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 f => Lifting Eq (Reverse f) where lifting :: Eq a :- Eq (Reverse f a)
lifting = (Eq a => Dict (Eq (Reverse f a))) -> Eq a :- Eq (Reverse f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Reverse f a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor Backwards where lifting :: Functor a :- Functor (Backwards a)
lifting = (Functor a => Dict (Functor (Backwards a)))
-> Functor a :- Functor (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable Backwards where lifting :: Foldable a :- Foldable (Backwards a)
lifting = (Foldable a => Dict (Foldable (Backwards a)))
-> Foldable a :- Foldable (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable Backwards where lifting :: Traversable a :- Traversable (Backwards a)
lifting = (Traversable a => Dict (Traversable (Backwards a)))
-> Traversable a :- Traversable (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Applicative Backwards where lifting :: Applicative a :- Applicative (Backwards a)
lifting = (Applicative a => Dict (Applicative (Backwards a)))
-> Applicative a :- Applicative (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Alternative Backwards where lifting :: Alternative a :- Alternative (Backwards a)
lifting = (Alternative a => Dict (Alternative (Backwards a)))
-> Alternative a :- Alternative (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show1 Backwards where lifting :: Show1 a :- Show1 (Backwards a)
lifting = (Show1 a => Dict (Show1 (Backwards a)))
-> Show1 a :- Show1 (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read1 Backwards where lifting :: Read1 a :- Read1 (Backwards a)
lifting = (Read1 a => Dict (Read1 (Backwards a)))
-> Read1 a :- Read1 (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord1 Backwards where lifting :: Ord1 a :- Ord1 (Backwards a)
lifting = (Ord1 a => Dict (Ord1 (Backwards a)))
-> Ord1 a :- Ord1 (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Eq1 Backwards where lifting :: Eq1 a :- Eq1 (Backwards a)
lifting = (Eq1 a => Dict (Eq1 (Backwards a))) -> Eq1 a :- Eq1 (Backwards a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (Backwards a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 f => Lifting Show (Backwards f) where lifting :: Show a :- Show (Backwards f a)
lifting = (Show a => Dict (Show (Backwards f a)))
-> Show a :- Show (Backwards f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Backwards f a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 f => Lifting Read (Backwards f) where lifting :: Read a :- Read (Backwards f a)
lifting = (Read a => Dict (Read (Backwards f a)))
-> Read a :- Read (Backwards f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Backwards f a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 f => Lifting Ord (Backwards f) where lifting :: Ord a :- Ord (Backwards f a)
lifting = (Ord a => Dict (Ord (Backwards f a)))
-> Ord a :- Ord (Backwards f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Backwards f a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 f => Lifting Eq (Backwards f) where lifting :: Eq a :- Eq (Backwards f a)
lifting = (Eq a => Dict (Eq (Backwards f a))) -> Eq a :- Eq (Backwards f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Backwards f a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Functor Lift where lifting :: Functor a :- Functor (Lift a)
lifting = (Functor a => Dict (Functor (Lift a)))
-> Functor a :- Functor (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable Lift where lifting :: Foldable a :- Foldable (Lift a)
lifting = (Foldable a => Dict (Foldable (Lift a)))
-> Foldable a :- Foldable (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable Lift where lifting :: Traversable a :- Traversable (Lift a)
lifting = (Traversable a => Dict (Traversable (Lift a)))
-> Traversable a :- Traversable (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Applicative Lift where lifting :: Applicative a :- Applicative (Lift a)
lifting = (Applicative a => Dict (Applicative (Lift a)))
-> Applicative a :- Applicative (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Alternative Lift where lifting :: Alternative a :- Alternative (Lift a)
lifting = (Alternative a => Dict (Alternative (Lift a)))
-> Alternative a :- Alternative (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show1 Lift where lifting :: Show1 a :- Show1 (Lift a)
lifting = (Show1 a => Dict (Show1 (Lift a))) -> Show1 a :- Show1 (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read1 Lift where lifting :: Read1 a :- Read1 (Lift a)
lifting = (Read1 a => Dict (Read1 (Lift a))) -> Read1 a :- Read1 (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord1 Lift where lifting :: Ord1 a :- Ord1 (Lift a)
lifting = (Ord1 a => Dict (Ord1 (Lift a))) -> Ord1 a :- Ord1 (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Eq1 Lift where lifting :: Eq1 a :- Eq1 (Lift a)
lifting = (Eq1 a => Dict (Eq1 (Lift a))) -> Eq1 a :- Eq1 (Lift a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (Lift a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 f => Lifting Show (Lift f) where lifting :: Show a :- Show (Lift f a)
lifting = (Show a => Dict (Show (Lift f a))) -> Show a :- Show (Lift f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Lift f a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 f => Lifting Read (Lift f) where lifting :: Read a :- Read (Lift f a)
lifting = (Read a => Dict (Read (Lift f a))) -> Read a :- Read (Lift f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Lift f a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 f => Lifting Ord (Lift f) where lifting :: Ord a :- Ord (Lift f a)
lifting = (Ord a => Dict (Ord (Lift f a))) -> Ord a :- Ord (Lift f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Lift f a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 f => Lifting Eq (Lift f) where lifting :: Eq a :- Eq (Lift f a)
lifting = (Eq a => Dict (Eq (Lift f a))) -> Eq a :- Eq (Lift f a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Lift f a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting Eq Identity where lifting :: Eq a :- Eq (Identity a)
lifting = (Eq a => Dict (Eq (Identity a))) -> Eq a :- Eq (Identity a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (Identity a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord Identity where lifting :: Ord a :- Ord (Identity a)
lifting = (Ord a => Dict (Ord (Identity a))) -> Ord a :- Ord (Identity a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (Identity a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show Identity where lifting :: Show a :- Show (Identity a)
lifting = (Show a => Dict (Show (Identity a))) -> Show a :- Show (Identity a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (Identity a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read Identity where lifting :: Read a :- Read (Identity a)
lifting = (Read a => Dict (Read (Identity a))) -> Read a :- Read (Identity a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (Identity a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting MonadCont MaybeT where lifting :: MonadCont a :- MonadCont (MaybeT a)
lifting = (MonadCont a => Dict (MonadCont (MaybeT a)))
-> MonadCont a :- MonadCont (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadCont IdentityT where lifting :: MonadCont a :- MonadCont (IdentityT a)
lifting = (MonadCont a => Dict (MonadCont (IdentityT a)))
-> MonadCont a :- MonadCont (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadCont (Strict.WriterT w) where lifting :: MonadCont a :- MonadCont (WriterT w a)
lifting = (MonadCont a => Dict (MonadCont (WriterT w a)))
-> MonadCont a :- MonadCont (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadCont (Lazy.WriterT w) where lifting :: MonadCont a :- MonadCont (WriterT w a)
lifting = (MonadCont a => Dict (MonadCont (WriterT w a)))
-> MonadCont a :- MonadCont (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadCont (ExceptT w) where lifting :: MonadCont a :- MonadCont (ExceptT w a)
lifting = (MonadCont a => Dict (MonadCont (ExceptT w a)))
-> MonadCont a :- MonadCont (ExceptT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (ExceptT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadCont (Strict.StateT s) where lifting :: MonadCont a :- MonadCont (StateT s a)
lifting = (MonadCont a => Dict (MonadCont (StateT s a)))
-> MonadCont a :- MonadCont (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadCont (Lazy.StateT s) where lifting :: MonadCont a :- MonadCont (StateT s a)
lifting = (MonadCont a => Dict (MonadCont (StateT s a)))
-> MonadCont a :- MonadCont (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadCont (ReaderT e) where lifting :: MonadCont a :- MonadCont (ReaderT e a)
lifting = (MonadCont a => Dict (MonadCont (ReaderT e a)))
-> MonadCont a :- MonadCont (ReaderT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (ReaderT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadCont (Strict.RWST r w s) where lifting :: MonadCont a :- MonadCont (RWST r w s a)
lifting = (MonadCont a => Dict (MonadCont (RWST r w s a)))
-> MonadCont a :- MonadCont (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting MonadCont (Lazy.RWST r w s) where lifting :: MonadCont a :- MonadCont (RWST r w s a)
lifting = (MonadCont a => Dict (MonadCont (RWST r w s a)))
-> MonadCont a :- MonadCont (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting (MonadError e) MaybeT where lifting :: MonadError e a :- MonadError e (MaybeT a)
lifting = (MonadError e a => Dict (MonadError e (MaybeT a)))
-> MonadError e a :- MonadError e (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadError e) IdentityT where lifting :: MonadError e a :- MonadError e (IdentityT a)
lifting = (MonadError e a => Dict (MonadError e (IdentityT a)))
-> MonadError e a :- MonadError e (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadError e) (Strict.WriterT w) where lifting :: MonadError e a :- MonadError e (WriterT w a)
lifting = (MonadError e a => Dict (MonadError e (WriterT w a)))
-> MonadError e a :- MonadError e (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadError e) (Lazy.WriterT w) where lifting :: MonadError e a :- MonadError e (WriterT w a)
lifting = (MonadError e a => Dict (MonadError e (WriterT w a)))
-> MonadError e a :- MonadError e (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadError e) (Strict.StateT s) where lifting :: MonadError e a :- MonadError e (StateT s a)
lifting = (MonadError e a => Dict (MonadError e (StateT s a)))
-> MonadError e a :- MonadError e (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadError e) (Lazy.StateT s) where lifting :: MonadError e a :- MonadError e (StateT s a)
lifting = (MonadError e a => Dict (MonadError e (StateT s a)))
-> MonadError e a :- MonadError e (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadError e) (ReaderT r) where lifting :: MonadError e a :- MonadError e (ReaderT r a)
lifting = (MonadError e a => Dict (MonadError e (ReaderT r a)))
-> MonadError e a :- MonadError e (ReaderT r a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (ReaderT r a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadError e) (Strict.RWST r w s) where lifting :: MonadError e a :- MonadError e (RWST r w s a)
lifting = (MonadError e a => Dict (MonadError e (RWST r w s a)))
-> MonadError e a :- MonadError e (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadError e) (Lazy.RWST r w s) where lifting :: MonadError e a :- MonadError e (RWST r w s a)
lifting = (MonadError e a => Dict (MonadError e (RWST r w s a)))
-> MonadError e a :- MonadError e (RWST r w s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (RWST r w s a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting (MonadRWS r w s) MaybeT where lifting :: MonadRWS r w s a :- MonadRWS r w s (MaybeT a)
lifting = (MonadRWS r w s a => Dict (MonadRWS r w s (MaybeT a)))
-> MonadRWS r w s a :- MonadRWS r w s (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadRWS r w s a => Dict (MonadRWS r w s (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadRWS r w s) IdentityT where lifting :: MonadRWS r w s a :- MonadRWS r w s (IdentityT a)
lifting = (MonadRWS r w s a => Dict (MonadRWS r w s (IdentityT a)))
-> MonadRWS r w s a :- MonadRWS r w s (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadRWS r w s a => Dict (MonadRWS r w s (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadRWS r w s) (ExceptT e) where lifting :: MonadRWS r w s a :- MonadRWS r w s (ExceptT e a)
lifting = (MonadRWS r w s a => Dict (MonadRWS r w s (ExceptT e a)))
-> MonadRWS r w s a :- MonadRWS r w s (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadRWS r w s a => Dict (MonadRWS r w s (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting (MonadReader r) MaybeT where lifting :: MonadReader r a :- MonadReader r (MaybeT a)
lifting = (MonadReader r a => Dict (MonadReader r (MaybeT a)))
-> MonadReader r a :- MonadReader r (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadReader r) IdentityT where lifting :: MonadReader r a :- MonadReader r (IdentityT a)
lifting = (MonadReader r a => Dict (MonadReader r (IdentityT a)))
-> MonadReader r a :- MonadReader r (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadReader r) (Strict.WriterT w) where lifting :: MonadReader r a :- MonadReader r (WriterT w a)
lifting = (MonadReader r a => Dict (MonadReader r (WriterT w a)))
-> MonadReader r a :- MonadReader r (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadReader r) (Lazy.WriterT w) where lifting :: MonadReader r a :- MonadReader r (WriterT w a)
lifting = (MonadReader r a => Dict (MonadReader r (WriterT w a)))
-> MonadReader r a :- MonadReader r (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadReader r) (Strict.StateT s) where lifting :: MonadReader r a :- MonadReader r (StateT s a)
lifting = (MonadReader r a => Dict (MonadReader r (StateT s a)))
-> MonadReader r a :- MonadReader r (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadReader r) (Lazy.StateT s) where lifting :: MonadReader r a :- MonadReader r (StateT s a)
lifting = (MonadReader r a => Dict (MonadReader r (StateT s a)))
-> MonadReader r a :- MonadReader r (StateT s a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (StateT s a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadReader r) (ExceptT e) where lifting :: MonadReader r a :- MonadReader r (ExceptT e a)
lifting = (MonadReader r a => Dict (MonadReader r (ExceptT e a)))
-> MonadReader r a :- MonadReader r (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadReader r) (ContT r') where lifting :: MonadReader r a :- MonadReader r (ContT r' a)
lifting = (MonadReader r a => Dict (MonadReader r (ContT r' a)))
-> MonadReader r a :- MonadReader r (ContT r' a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (ContT r' a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting (MonadState s) MaybeT where lifting :: MonadState s a :- MonadState s (MaybeT a)
lifting = (MonadState s a => Dict (MonadState s (MaybeT a)))
-> MonadState s a :- MonadState s (MaybeT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (MaybeT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadState s) IdentityT where lifting :: MonadState s a :- MonadState s (IdentityT a)
lifting = (MonadState s a => Dict (MonadState s (IdentityT a)))
-> MonadState s a :- MonadState s (IdentityT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (IdentityT a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadState s) (Strict.WriterT w) where lifting :: MonadState s a :- MonadState s (WriterT w a)
lifting = (MonadState s a => Dict (MonadState s (WriterT w a)))
-> MonadState s a :- MonadState s (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Monoid w => Lifting (MonadState s) (Lazy.WriterT w) where lifting :: MonadState s a :- MonadState s (WriterT w a)
lifting = (MonadState s a => Dict (MonadState s (WriterT w a)))
-> MonadState s a :- MonadState s (WriterT w a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (WriterT w a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadState s) (ReaderT r) where lifting :: MonadState s a :- MonadState s (ReaderT r a)
lifting = (MonadState s a => Dict (MonadState s (ReaderT r a)))
-> MonadState s a :- MonadState s (ReaderT r a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (ReaderT r a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadState s) (ExceptT e) where lifting :: MonadState s a :- MonadState s (ExceptT e a)
lifting = (MonadState s a => Dict (MonadState s (ExceptT e a)))
-> MonadState s a :- MonadState s (ExceptT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (ExceptT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadState s) (ContT r') where lifting :: MonadState s a :- MonadState s (ContT r' a)
lifting = (MonadState s a => Dict (MonadState s (ContT r' a)))
-> MonadState s a :- MonadState s (ContT r' a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (ContT r' a))
forall (a :: Constraint). a => Dict a
Dict

#if !(MIN_VERSION_transformers(0,6,0))
instance Lifting Functor (ErrorT e) where lifting :: Functor a :- Functor (ErrorT e a)
lifting = (Functor a => Dict (Functor (ErrorT e a)))
-> Functor a :- Functor (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Foldable (ErrorT e) where lifting :: Foldable a :- Foldable (ErrorT e a)
lifting = (Foldable a => Dict (Foldable (ErrorT e a)))
-> Foldable a :- Foldable (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable (ErrorT e) where lifting :: Traversable a :- Traversable (ErrorT e a)
lifting = (Traversable a => Dict (Traversable (ErrorT e a)))
-> Traversable a :- Traversable (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Error e => Lifting Monad (ErrorT e) where lifting :: Monad a :- Monad (ErrorT e a)
lifting = (Monad a => Dict (Monad (ErrorT e a)))
-> Monad a :- Monad (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Error e => Lifting MonadFix (ErrorT e) where lifting :: MonadFix a :- MonadFix (ErrorT e a)
lifting = (MonadFix a => Dict (MonadFix (ErrorT e a)))
-> MonadFix a :- MonadFix (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (MonadFix (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Error e => Lifting MonadPlus (ErrorT e) where lifting :: MonadPlus a :- MonadPlus (ErrorT e a)
lifting = (MonadPlus a => Dict (MonadPlus (ErrorT e a)))
-> MonadPlus a :- MonadPlus (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained!
instance Error e => Lifting MonadIO (ErrorT e) where lifting :: MonadIO a :- MonadIO (ErrorT e a)
lifting = (MonadIO a => Dict (MonadIO (ErrorT e a)))
-> MonadIO a :- MonadIO (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Show e => Lifting Show1 (ErrorT e) where lifting :: Show1 a :- Show1 (ErrorT e a)
lifting = (Show1 a => Dict (Show1 (ErrorT e a)))
-> Show1 a :- Show1 (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq e => Lifting Eq1 (ErrorT e) where lifting :: Eq1 a :- Eq1 (ErrorT e a)
lifting = (Eq1 a => Dict (Eq1 (ErrorT e a))) -> Eq1 a :- Eq1 (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord e => Lifting Ord1 (ErrorT e) where lifting :: Ord1 a :- Ord1 (ErrorT e a)
lifting = (Ord1 a => Dict (Ord1 (ErrorT e a))) -> Ord1 a :- Ord1 (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Read e => Lifting Read1 (ErrorT e) where lifting :: Read1 a :- Read1 (ErrorT e a)
lifting = (Read1 a => Dict (Read1 (ErrorT e a)))
-> Read1 a :- Read1 (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance (Show e, Show1 m) => Lifting Show (ErrorT e m) where lifting :: Show a :- Show (ErrorT e m a)
lifting = (Show a => Dict (Show (ErrorT e m a)))
-> Show a :- Show (ErrorT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (ErrorT e m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Eq e, Eq1 m) => Lifting Eq (ErrorT e m) where lifting :: Eq a :- Eq (ErrorT e m a)
lifting = (Eq a => Dict (Eq (ErrorT e m a))) -> Eq a :- Eq (ErrorT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (ErrorT e m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Ord e, Ord1 m) => Lifting Ord (ErrorT e m) where lifting :: Ord a :- Ord (ErrorT e m a)
lifting = (Ord a => Dict (Ord (ErrorT e m a))) -> Ord a :- Ord (ErrorT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (ErrorT e m a))
forall (a :: Constraint). a => Dict a
Dict
instance (Read e, Read1 m) => Lifting Read (ErrorT e m) where lifting :: Read a :- Read (ErrorT e m a)
lifting = (Read a => Dict (Read (ErrorT e m a)))
-> Read a :- Read (ErrorT e m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (ErrorT e m a))
forall (a :: Constraint). a => Dict a
Dict
# if !(MIN_VERSION_mtl(2,3,0))
instance Error e => Lifting MonadCont (ErrorT e) where lifting :: MonadCont a :- MonadCont (ErrorT e a)
lifting = (MonadCont a => Dict (MonadCont (ErrorT e a)))
-> MonadCont a :- MonadCont (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Error e => Lifting (MonadRWS r w s) (ErrorT e) where lifting :: MonadRWS r w s a :- MonadRWS r w s (ErrorT e a)
lifting = (MonadRWS r w s a => Dict (MonadRWS r w s (ErrorT e a)))
-> MonadRWS r w s a :- MonadRWS r w s (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadRWS r w s a => Dict (MonadRWS r w s (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Error e => Lifting (MonadReader r) (ErrorT e) where lifting :: MonadReader r a :- MonadReader r (ErrorT e a)
lifting = (MonadReader r a => Dict (MonadReader r (ErrorT e a)))
-> MonadReader r a :- MonadReader r (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
instance Error e => Lifting (MonadState s) (ErrorT e) where lifting :: MonadState s a :- MonadState s (ErrorT e a)
lifting = (MonadState s a => Dict (MonadState s (ErrorT e a)))
-> MonadState s a :- MonadState s (ErrorT e a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (ErrorT e a))
forall (a :: Constraint). a => Dict a
Dict
# endif

instance Lifting Functor ListT where lifting :: Functor a :- Functor (ListT a)
lifting = (Functor a => Dict (Functor (ListT a)))
-> Functor a :- Functor (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Functor (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Applicative ListT where lifting :: Applicative a :- Applicative (ListT a)
lifting = (Applicative a => Dict (Applicative (ListT a)))
-> Applicative a :- Applicative (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Applicative (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Alternative ListT where lifting :: Alternative a :- Alternative (ListT a)
lifting = (Alternative a => Dict (Alternative (ListT a)))
-> Alternative a :- Alternative (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Alternative (ListT a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained
instance Lifting Monad ListT where lifting :: Monad a :- Monad (ListT a)
lifting = (Monad a => Dict (Monad (ListT a))) -> Monad a :- Monad (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Monad (ListT a))
forall (a :: Constraint). a => Dict a
Dict
-- instance Lifting MonadFix ListT where lifting = Sub Dict
instance Lifting MonadPlus ListT where lifting :: MonadPlus a :- MonadPlus (ListT a)
lifting = (MonadPlus a => Dict (MonadPlus (ListT a)))
-> MonadPlus a :- MonadPlus (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (MonadPlus (ListT a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained
instance Lifting Foldable ListT where lifting :: Foldable a :- Foldable (ListT a)
lifting = (Foldable a => Dict (Foldable (ListT a)))
-> Foldable a :- Foldable (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Foldable (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Traversable ListT where lifting :: Traversable a :- Traversable (ListT a)
lifting = (Traversable a => Dict (Traversable (ListT a)))
-> Traversable a :- Traversable (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Traversable (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting MonadIO ListT where lifting :: MonadIO a :- MonadIO (ListT a)
lifting = (MonadIO a => Dict (MonadIO (ListT a)))
-> MonadIO a :- MonadIO (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadIO a => Dict (MonadIO (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Show1 ListT where lifting :: Show1 a :- Show1 (ListT a)
lifting = (Show1 a => Dict (Show1 (ListT a))) -> Show1 a :- Show1 (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Show1 (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Read1 ListT where lifting :: Read1 a :- Read1 (ListT a)
lifting = (Read1 a => Dict (Read1 (ListT a))) -> Read1 a :- Read1 (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Read1 (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Ord1 ListT where lifting :: Ord1 a :- Ord1 (ListT a)
lifting = (Ord1 a => Dict (Ord1 (ListT a))) -> Ord1 a :- Ord1 (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Ord1 (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting Eq1 ListT where lifting :: Eq1 a :- Eq1 (ListT a)
lifting = (Eq1 a => Dict (Eq1 (ListT a))) -> Eq1 a :- Eq1 (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Eq1 (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Show1 m => Lifting Show (ListT m) where lifting :: Show a :- Show (ListT m a)
lifting = (Show a => Dict (Show (ListT m a))) -> Show a :- Show (ListT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Show (ListT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Read1 m => Lifting Read (ListT m) where lifting :: Read a :- Read (ListT m a)
lifting = (Read a => Dict (Read (ListT m a))) -> Read a :- Read (ListT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Read (ListT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Ord1 m => Lifting Ord (ListT m) where lifting :: Ord a :- Ord (ListT m a)
lifting = (Ord a => Dict (Ord (ListT m a))) -> Ord a :- Ord (ListT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Ord (ListT m a))
forall (a :: Constraint). a => Dict a
Dict
instance Eq1 m => Lifting Eq (ListT m) where lifting :: Eq a :- Eq (ListT m a)
lifting = (Eq a => Dict (Eq (ListT m a))) -> Eq a :- Eq (ListT m a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Eq (ListT m a))
forall (a :: Constraint). a => Dict a
Dict
# if !(MIN_VERSION_mtl(2,3,0))
instance Lifting MonadCont ListT where lifting :: MonadCont a :- MonadCont (ListT a)
lifting = (MonadCont a => Dict (MonadCont (ListT a)))
-> MonadCont a :- MonadCont (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadCont a => Dict (MonadCont (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadError e) ListT where lifting :: MonadError e a :- MonadError e (ListT a)
lifting = (MonadError e a => Dict (MonadError e (ListT a)))
-> MonadError e a :- MonadError e (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadError e a => Dict (MonadError e (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadReader r) ListT where lifting :: MonadReader r a :- MonadReader r (ListT a)
lifting = (MonadReader r a => Dict (MonadReader r (ListT a)))
-> MonadReader r a :- MonadReader r (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadReader r a => Dict (MonadReader r (ListT a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting (MonadState s) ListT where lifting :: MonadState s a :- MonadState s (ListT a)
lifting = (MonadState s a => Dict (MonadState s (ListT a)))
-> MonadState s a :- MonadState s (ListT a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadState s a => Dict (MonadState s (ListT a))
forall (a :: Constraint). a => Dict a
Dict
# endif
#endif

class Lifting2 p f where
  lifting2 :: p a :- Lifting p (f a) -- (p a, p b) :- p (f a b)

instance Lifting2 Eq Either where lifting2 :: Eq a :- Lifting Eq (Either a)
lifting2 = (Eq a => Dict (Lifting Eq (Either a)))
-> Eq a :- Lifting Eq (Either a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Lifting Eq (Either a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Ord Either where lifting2 :: Ord a :- Lifting Ord (Either a)
lifting2 = (Ord a => Dict (Lifting Ord (Either a)))
-> Ord a :- Lifting Ord (Either a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Lifting Ord (Either a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Show Either where lifting2 :: Show a :- Lifting Show (Either a)
lifting2 = (Show a => Dict (Lifting Show (Either a)))
-> Show a :- Lifting Show (Either a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Lifting Show (Either a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Read Either where lifting2 :: Read a :- Lifting Read (Either a)
lifting2 = (Read a => Dict (Lifting Read (Either a)))
-> Read a :- Lifting Read (Either a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Lifting Read (Either a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Hashable Either where lifting2 :: Hashable a :- Lifting Hashable (Either a)
lifting2 = (Hashable a => Dict (Lifting Hashable (Either a)))
-> Hashable a :- Lifting Hashable (Either a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Hashable a => Dict (Lifting Hashable (Either a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Binary Either where lifting2 :: Binary a :- Lifting Binary (Either a)
lifting2 = (Binary a => Dict (Lifting Binary (Either a)))
-> Binary a :- Lifting Binary (Either a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Binary a => Dict (Lifting Binary (Either a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 NFData Either where lifting2 :: NFData a :- Lifting NFData (Either a)
lifting2 = (NFData a => Dict (Lifting NFData (Either a)))
-> NFData a :- Lifting NFData (Either a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub NFData a => Dict (Lifting NFData (Either a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting2 Eq (,) where lifting2 :: Eq a :- Lifting Eq ((,) a)
lifting2 = (Eq a => Dict (Lifting Eq ((,) a))) -> Eq a :- Lifting Eq ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq a => Dict (Lifting Eq ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Ord (,) where lifting2 :: Ord a :- Lifting Ord ((,) a)
lifting2 = (Ord a => Dict (Lifting Ord ((,) a)))
-> Ord a :- Lifting Ord ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord a => Dict (Lifting Ord ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Show (,) where lifting2 :: Show a :- Lifting Show ((,) a)
lifting2 = (Show a => Dict (Lifting Show ((,) a)))
-> Show a :- Lifting Show ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show a => Dict (Lifting Show ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Read (,) where lifting2 :: Read a :- Lifting Read ((,) a)
lifting2 = (Read a => Dict (Lifting Read ((,) a)))
-> Read a :- Lifting Read ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read a => Dict (Lifting Read ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Hashable (,) where lifting2 :: Hashable a :- Lifting Hashable ((,) a)
lifting2 = (Hashable a => Dict (Lifting Hashable ((,) a)))
-> Hashable a :- Lifting Hashable ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Hashable a => Dict (Lifting Hashable ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Binary (,) where lifting2 :: Binary a :- Lifting Binary ((,) a)
lifting2 = (Binary a => Dict (Lifting Binary ((,) a)))
-> Binary a :- Lifting Binary ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Binary a => Dict (Lifting Binary ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 NFData (,) where lifting2 :: NFData a :- Lifting NFData ((,) a)
lifting2 = (NFData a => Dict (Lifting NFData ((,) a)))
-> NFData a :- Lifting NFData ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub NFData a => Dict (Lifting NFData ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Semigroup (,) where lifting2 :: Semigroup a :- Lifting Semigroup ((,) a)
lifting2 = (Semigroup a => Dict (Lifting Semigroup ((,) a)))
-> Semigroup a :- Lifting Semigroup ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Semigroup a => Dict (Lifting Semigroup ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Monoid (,) where lifting2 :: Monoid a :- Lifting Monoid ((,) a)
lifting2 = (Monoid a => Dict (Lifting Monoid ((,) a)))
-> Monoid a :- Lifting Monoid ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monoid a => Dict (Lifting Monoid ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Bounded (,) where lifting2 :: Bounded a :- Lifting Bounded ((,) a)
lifting2 = (Bounded a => Dict (Lifting Bounded ((,) a)))
-> Bounded a :- Lifting Bounded ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Bounded a => Dict (Lifting Bounded ((,) a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Ix (,) where lifting2 :: Ix a :- Lifting Ix ((,) a)
lifting2 = (Ix a => Dict (Lifting Ix ((,) a))) -> Ix a :- Lifting Ix ((,) a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ix a => Dict (Lifting Ix ((,) a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting2 Functor Compose where lifting2 :: Functor a :- Lifting Functor (Compose a)
lifting2 = (Functor a => Dict (Lifting Functor (Compose a)))
-> Functor a :- Lifting Functor (Compose a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Lifting Functor (Compose a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Foldable Compose where lifting2 :: Foldable a :- Lifting Foldable (Compose a)
lifting2 = (Foldable a => Dict (Lifting Foldable (Compose a)))
-> Foldable a :- Lifting Foldable (Compose a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Lifting Foldable (Compose a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Traversable Compose where lifting2 :: Traversable a :- Lifting Traversable (Compose a)
lifting2 = (Traversable a => Dict (Lifting Traversable (Compose a)))
-> Traversable a :- Lifting Traversable (Compose a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Lifting Traversable (Compose a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Applicative Compose where lifting2 :: Applicative a :- Lifting Applicative (Compose a)
lifting2 = (Applicative a => Dict (Lifting Applicative (Compose a)))
-> Applicative a :- Lifting Applicative (Compose a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Lifting Applicative (Compose a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Alternative Compose where lifting2 :: Alternative a :- Lifting Alternative (Compose a)
lifting2 = (Alternative a => Dict (Lifting Alternative (Compose a)))
-> Alternative a :- Lifting Alternative (Compose a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Lifting Alternative (Compose a))
forall (a :: Constraint). a => Dict a
Dict -- overconstrained

instance Lifting2 Functor Functor.Product where lifting2 :: Functor a :- Lifting Functor (Product a)
lifting2 = (Functor a => Dict (Lifting Functor (Product a)))
-> Functor a :- Lifting Functor (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Lifting Functor (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Foldable Functor.Product where lifting2 :: Foldable a :- Lifting Foldable (Product a)
lifting2 = (Foldable a => Dict (Lifting Foldable (Product a)))
-> Foldable a :- Lifting Foldable (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Lifting Foldable (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Traversable Functor.Product where lifting2 :: Traversable a :- Lifting Traversable (Product a)
lifting2 = (Traversable a => Dict (Lifting Traversable (Product a)))
-> Traversable a :- Lifting Traversable (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Lifting Traversable (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Applicative Functor.Product where lifting2 :: Applicative a :- Lifting Applicative (Product a)
lifting2 = (Applicative a => Dict (Lifting Applicative (Product a)))
-> Applicative a :- Lifting Applicative (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Applicative a => Dict (Lifting Applicative (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Alternative Functor.Product where lifting2 :: Alternative a :- Lifting Alternative (Product a)
lifting2 = (Alternative a => Dict (Lifting Alternative (Product a)))
-> Alternative a :- Lifting Alternative (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Alternative a => Dict (Lifting Alternative (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Monad Functor.Product where lifting2 :: Monad a :- Lifting Monad (Product a)
lifting2 = (Monad a => Dict (Lifting Monad (Product a)))
-> Monad a :- Lifting Monad (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Monad a => Dict (Lifting Monad (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 MonadPlus Functor.Product where lifting2 :: MonadPlus a :- Lifting MonadPlus (Product a)
lifting2 = (MonadPlus a => Dict (Lifting MonadPlus (Product a)))
-> MonadPlus a :- Lifting MonadPlus (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadPlus a => Dict (Lifting MonadPlus (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 MonadFix Functor.Product where lifting2 :: MonadFix a :- Lifting MonadFix (Product a)
lifting2 = (MonadFix a => Dict (Lifting MonadFix (Product a)))
-> MonadFix a :- Lifting MonadFix (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub MonadFix a => Dict (Lifting MonadFix (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Show1 Functor.Product where lifting2 :: Show1 a :- Lifting Show1 (Product a)
lifting2 = (Show1 a => Dict (Lifting Show1 (Product a)))
-> Show1 a :- Lifting Show1 (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Lifting Show1 (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Eq1 Functor.Product where lifting2 :: Eq1 a :- Lifting Eq1 (Product a)
lifting2 = (Eq1 a => Dict (Lifting Eq1 (Product a)))
-> Eq1 a :- Lifting Eq1 (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Lifting Eq1 (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Ord1 Functor.Product where lifting2 :: Ord1 a :- Lifting Ord1 (Product a)
lifting2 = (Ord1 a => Dict (Lifting Ord1 (Product a)))
-> Ord1 a :- Lifting Ord1 (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Lifting Ord1 (Product a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Read1 Functor.Product where lifting2 :: Read1 a :- Lifting Read1 (Product a)
lifting2 = (Read1 a => Dict (Lifting Read1 (Product a)))
-> Read1 a :- Lifting Read1 (Product a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Lifting Read1 (Product a))
forall (a :: Constraint). a => Dict a
Dict

instance Lifting2 Functor Functor.Sum where lifting2 :: Functor a :- Lifting Functor (Sum a)
lifting2 = (Functor a => Dict (Lifting Functor (Sum a)))
-> Functor a :- Lifting Functor (Sum a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Functor a => Dict (Lifting Functor (Sum a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Foldable Functor.Sum where lifting2 :: Foldable a :- Lifting Foldable (Sum a)
lifting2 = (Foldable a => Dict (Lifting Foldable (Sum a)))
-> Foldable a :- Lifting Foldable (Sum a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Foldable a => Dict (Lifting Foldable (Sum a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Traversable Functor.Sum where lifting2 :: Traversable a :- Lifting Traversable (Sum a)
lifting2 = (Traversable a => Dict (Lifting Traversable (Sum a)))
-> Traversable a :- Lifting Traversable (Sum a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Traversable a => Dict (Lifting Traversable (Sum a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Show1 Functor.Sum where lifting2 :: Show1 a :- Lifting Show1 (Sum a)
lifting2 = (Show1 a => Dict (Lifting Show1 (Sum a)))
-> Show1 a :- Lifting Show1 (Sum a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Show1 a => Dict (Lifting Show1 (Sum a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Eq1 Functor.Sum where lifting2 :: Eq1 a :- Lifting Eq1 (Sum a)
lifting2 = (Eq1 a => Dict (Lifting Eq1 (Sum a)))
-> Eq1 a :- Lifting Eq1 (Sum a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Eq1 a => Dict (Lifting Eq1 (Sum a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Ord1 Functor.Sum where lifting2 :: Ord1 a :- Lifting Ord1 (Sum a)
lifting2 = (Ord1 a => Dict (Lifting Ord1 (Sum a)))
-> Ord1 a :- Lifting Ord1 (Sum a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Ord1 a => Dict (Lifting Ord1 (Sum a))
forall (a :: Constraint). a => Dict a
Dict
instance Lifting2 Read1 Functor.Sum where lifting2 :: Read1 a :- Lifting Read1 (Sum a)
lifting2 = (Read1 a => Dict (Lifting Read1 (Sum a)))
-> Read1 a :- Lifting Read1 (Sum a)
forall (a :: Constraint) (b :: Constraint). (a => Dict b) -> a :- b
Sub Read1 a => Dict (Lifting Read1 (Sum a))
forall (a :: Constraint). a => Dict a
Dict