Data.Functor.Invariant

Haskell98 invariant functors (also known as exponential functors).

For more information, see Edward Kmett's article "Rotten Bananas":

http://comonad.com/reader/2008/rotten-bananas/

Invariant

class Invariant f where

Any * -> * type parametric in the argument permits an instance of Invariant.

Instances should satisfy the following laws:

invmap id id = id
invmap f2 f2' . invmap f1 f1' = invmap (f2 . f1) (f1' . f2')

Methods

invmap :: (a -> b) -> (b -> a) -> f a -> f b

invmap :: (Generic1 f, Invariant (Rep1 f)) => (a -> b) -> (b -> a) -> f a -> f b

Instances

Invariant []

Methods

invmap :: (a -> b) -> (b -> a) -> [a] -> [b]

Invariant Maybe

Methods

invmap :: (a -> b) -> (b -> a) -> Maybe a -> Maybe b

Invariant IO

Methods

invmap :: (a -> b) -> (b -> a) -> IO a -> IO b

Invariant V1

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> V1 a -> V1 b

Invariant U1

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> U1 a -> U1 b

Invariant Par1

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> Par1 a -> Par1 b

Invariant UAddr

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> UAddr a -> UAddr b

Invariant UChar

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> UChar a -> UChar b

Invariant UDouble

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> UDouble a -> UDouble b

Invariant UFloat

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> UFloat a -> UFloat b

Invariant UInt

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> UInt a -> UInt b

Invariant UWord

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> UWord a -> UWord b

Invariant StateVar

from the StateVar package

Methods

invmap :: (a -> b) -> (b -> a) -> StateVar a -> StateVar b

Invariant SettableStateVar

from the StateVar package

Methods

invmap :: (a -> b) -> (b -> a) -> SettableStateVar a -> SettableStateVar b

Invariant Identity

from Data.Functor.Identity

Methods

invmap :: (a -> b) -> (b -> a) -> Identity a -> Identity b

Invariant Min

from Data.Semigroup

Methods

invmap :: (a -> b) -> (b -> a) -> Min a -> Min b

Invariant Max

from Data.Semigroup

Methods

invmap :: (a -> b) -> (b -> a) -> Max a -> Max b

Invariant First

from Data.Semigroup

Methods

invmap :: (a -> b) -> (b -> a) -> First a -> First b

Invariant Last

from Data.Semigroup

Methods

invmap :: (a -> b) -> (b -> a) -> Last a -> Last b

Invariant Option

from Data.Semigroup

Methods

invmap :: (a -> b) -> (b -> a) -> Option a -> Option b

Invariant NonEmpty

from Data.List.NonEmpty

Methods

invmap :: (a -> b) -> (b -> a) -> NonEmpty a -> NonEmpty b

Invariant Complex

from Data.Complex

Methods

invmap :: (a -> b) -> (b -> a) -> Complex a -> Complex b

Invariant ArgOrder

from System.Console.GetOpt

Methods

invmap :: (a -> b) -> (b -> a) -> ArgOrder a -> ArgOrder b

Invariant OptDescr

from System.Console.GetOpt

Methods

invmap :: (a -> b) -> (b -> a) -> OptDescr a -> OptDescr b

Invariant ArgDescr

from System.Console.GetOpt

Methods

invmap :: (a -> b) -> (b -> a) -> ArgDescr a -> ArgDescr b

Invariant ZipList

from Control.Applicative

Methods

invmap :: (a -> b) -> (b -> a) -> ZipList a -> ZipList b

Invariant Handler

from Control.Exception

Methods

invmap :: (a -> b) -> (b -> a) -> Handler a -> Handler b

Invariant STM

from the stm package

Methods

invmap :: (a -> b) -> (b -> a) -> STM a -> STM b

Invariant Dual

from Data.Monoid

Methods

invmap :: (a -> b) -> (b -> a) -> Dual a -> Dual b

Invariant Endo

from Data.Monoid

Methods

invmap :: (a -> b) -> (b -> a) -> Endo a -> Endo b

Invariant Sum

from Data.Monoid

Methods

invmap :: (a -> b) -> (b -> a) -> Sum a -> Sum b

Invariant Product

from Data.Monoid

Methods

invmap :: (a -> b) -> (b -> a) -> Product a -> Product b

Invariant First

from Data.Monoid

Methods

invmap :: (a -> b) -> (b -> a) -> First a -> First b

Invariant Last

from Data.Monoid

Methods

invmap :: (a -> b) -> (b -> a) -> Last a -> Last b

Invariant ReadPrec

Methods

invmap :: (a -> b) -> (b -> a) -> ReadPrec a -> ReadPrec b

Invariant ReadP

Methods

invmap :: (a -> b) -> (b -> a) -> ReadP a -> ReadP b

Invariant IntMap

from the containers package

Methods

invmap :: (a -> b) -> (b -> a) -> IntMap a -> IntMap b

Invariant Tree

from the containers package

Methods

invmap :: (a -> b) -> (b -> a) -> Tree a -> Tree b

Invariant Seq

from the containers package

Methods

invmap :: (a -> b) -> (b -> a) -> Seq a -> Seq b

Invariant ViewL

from the containers package

Methods

invmap :: (a -> b) -> (b -> a) -> ViewL a -> ViewL b

Invariant ViewR

from the containers package

Methods

invmap :: (a -> b) -> (b -> a) -> ViewR a -> ViewR b

Invariant Predicate

from the contravariant package

Methods

invmap :: (a -> b) -> (b -> a) -> Predicate a -> Predicate b

Invariant Comparison

from the contravariant package

Methods

invmap :: (a -> b) -> (b -> a) -> Comparison a -> Comparison b

Invariant Equivalence

from the contravariant package

Methods

invmap :: (a -> b) -> (b -> a) -> Equivalence a -> Equivalence b

Invariant ((->) a)

Methods

invmap :: (a -> b) -> (b -> a) -> (a -> a) -> a -> b

Invariant (Either a)

Methods

invmap :: (a -> b) -> (b -> a) -> Either a a -> Either a b

Invariant f => Invariant (Rec1 f)

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> Rec1 f a -> Rec1 f b

Invariant ((,) a)

Methods

invmap :: (a -> b) -> (b -> a) -> (a, a) -> (a, b)

Invariant (ST s)

Methods

invmap :: (a -> b) -> (b -> a) -> ST s a -> ST s b

Invariant (Array i)

from the array package

Methods

invmap :: (a -> b) -> (b -> a) -> Array i a -> Array i b

Invariant (Arg a)

from Data.Semigroup

Methods

invmap :: (a -> b) -> (b -> a) -> Arg a a -> Arg a b

Invariant (ST s)

Methods

invmap :: (a -> b) -> (b -> a) -> ST s a -> ST s b

Monad m => Invariant (WrappedMonad m)

from Control.Applicative

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedMonad m a -> WrappedMonad m b

Arrow a => Invariant (ArrowMonad a)

from Control.Arrow

Methods

invmap :: (a -> b) -> (b -> a) -> ArrowMonad a a -> ArrowMonad a b

Invariant (Proxy *)

from Data.Proxy

Methods

invmap :: (a -> b) -> (b -> a) -> Proxy * a -> Proxy * b

Invariant (Map k)

from the containers package

Methods

invmap :: (a -> b) -> (b -> a) -> Map k a -> Map k b

Invariant (Op a)

from the contravariant package

Methods

invmap :: (a -> b) -> (b -> a) -> Op a a -> Op a b

Invariant2 p => Invariant (Prep p)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Prep p a -> Prep p b

Invariant2 p => Invariant (Coprep p)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Coprep p a -> Coprep p b

Invariant f => Invariant (Lift f)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> Lift f a -> Lift f b

Invariant m => Invariant (MaybeT m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> MaybeT m a -> MaybeT m b

Invariant m => Invariant (ListT m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> ListT m a -> ListT m b

Invariant (HashMap k)

from the unordered-containers package

Methods

invmap :: (a -> b) -> (b -> a) -> HashMap k a -> HashMap k b

Invariant (K1 i c)

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> K1 i c a -> K1 i c b

(Invariant l, Invariant r) => Invariant ((:+:) l r)

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> (l :+: r) a -> (l :+: r) b

(Invariant l, Invariant r) => Invariant ((:*:) l r)

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> (l :*: r) a -> (l :*: r) b

(Invariant f, Invariant g) => Invariant ((:.:) f g)

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> (f :.: g) a -> (f :.: g) b

Invariant ((,,) a b)

Methods

invmap :: (a -> b) -> (b -> a) -> (a, b, a) -> (a, b, b)

Arrow arr => Invariant (WrappedArrow arr a)

from Control.Applicative

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedArrow arr a a -> WrappedArrow arr a b

Monad m => Invariant (Kleisli m a)

from Control.Arrow

Methods

invmap :: (a -> b) -> (b -> a) -> Kleisli m a a -> Kleisli m a b

Invariant (Const * a)

from Control.Applicative

Methods

invmap :: (a -> b) -> (b -> a) -> Const * a a -> Const * a b

Invariant f => Invariant (Alt * f)

from Data.Monoid

Methods

invmap :: (a -> b) -> (b -> a) -> Alt * f a -> Alt * f b

Invariant2 p => Invariant (Join * p)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Join * p a -> Join * p b

Invariant2 p => Invariant (Fix * p)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Fix * p a -> Fix * p b

Invariant (Cokleisli w a)

from the comonad package

Methods

invmap :: (a -> b) -> (b -> a) -> Cokleisli w a a -> Cokleisli w a b

Invariant m => Invariant (IdentityT * m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> IdentityT * m a -> IdentityT * m b

(Invariant f, Invariant g) => Invariant (Compose f g)

from the contravariant package

Methods

invmap :: (a -> b) -> (b -> a) -> Compose f g a -> Compose f g b

(Invariant f, Invariant g) => Invariant (ComposeFC f g)

from the contravariant package

Methods

invmap :: (a -> b) -> (b -> a) -> ComposeFC f g a -> ComposeFC f g b

(Invariant f, Invariant g) => Invariant (ComposeCF f g)

from the contravariant package

Methods

invmap :: (a -> b) -> (b -> a) -> ComposeCF f g a -> ComposeCF f g b

Invariant2 p => Invariant (Codensity p a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Codensity p a a -> Codensity p a b

Invariant2 p => Invariant (Closure p a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Closure p a a -> Closure p a b

Invariant2 p => Invariant (TambaraSum p a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> TambaraSum p a a -> TambaraSum p a b

Invariant (CotambaraSum p a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> CotambaraSum p a a -> CotambaraSum p a b

Invariant2 p => Invariant (Tambara p a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Tambara p a a -> Tambara p a b

Invariant (Cotambara p a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Cotambara p a a -> Cotambara p a b

Invariant f => Invariant (Star f a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Star f a a -> Star f a b

Invariant (Costar f a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Costar f a a -> Costar f a b

Arrow arr => Invariant (WrappedArrow arr a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedArrow arr a a -> WrappedArrow arr a b

Invariant (Forget r a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Forget r a a -> Forget r a b

Invariant (Tagged k s)

from the tagged package

Methods

invmap :: (a -> b) -> (b -> a) -> Tagged k s a -> Tagged k s b

Invariant f => Invariant (Reverse * f)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> Reverse * f a -> Reverse * f b

Invariant f => Invariant (Backwards * f)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> Backwards * f a -> Backwards * f b

Invariant m => Invariant (WriterT w m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> WriterT w m a -> WriterT w m b

Invariant m => Invariant (WriterT w m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> WriterT w m a -> WriterT w m b

Invariant m => Invariant (StateT s m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> StateT s m a -> StateT s m b

Invariant m => Invariant (StateT s m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> StateT s m a -> StateT s m b

Invariant m => Invariant (ExceptT e m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> ExceptT e m a -> ExceptT e m b

Invariant m => Invariant (ErrorT e m)

Methods

invmap :: (a -> b) -> (b -> a) -> ErrorT e m a -> ErrorT e m b

Invariant (Constant * a)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> Constant * a a -> Constant * a b

Contravariant f => Invariant (WrappedContravariant * f)

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedContravariant * f a -> WrappedContravariant * f b

Functor f => Invariant (WrappedFunctor * f)

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedFunctor * f a -> WrappedFunctor * f b

Invariant f => Invariant (M1 i t f)

from GHC.Generics

Methods

invmap :: (a -> b) -> (b -> a) -> M1 i t f a -> M1 i t f b

Invariant ((,,,) a b c)

Methods

invmap :: (a -> b) -> (b -> a) -> (a, b, c, a) -> (a, b, c, b)

(Invariant f, Invariant g) => Invariant (Sum * f g)

from Data.Functor.Sum

Methods

invmap :: (a -> b) -> (b -> a) -> Sum * f g a -> Sum * f g b

(Invariant f, Invariant g) => Invariant (Product * f g)

from Data.Functor.Product

Methods

invmap :: (a -> b) -> (b -> a) -> Product * f g a -> Product * f g b

Invariant2 q => Invariant (Ran p q a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Ran p q a a -> Ran p q a b

Invariant2 p => Invariant (Procompose p q a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Procompose p q a a -> Procompose p q a b

Invariant2 p => Invariant (Rift p q a)

from the profunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Rift p q a a -> Rift p q a b

Invariant m => Invariant (ReaderT * r m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> ReaderT * r m a -> ReaderT * r m b

Invariant (ContT k r m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> ContT k r m a -> ContT k r m b

Invariant ((,,,,) a b c d)

Methods

invmap :: (a -> b) -> (b -> a) -> (a, b, c, d, a) -> (a, b, c, d, b)

(Invariant f, Invariant g) => Invariant (Compose * * f g)

from Data.Functor.Compose

Methods

invmap :: (a -> b) -> (b -> a) -> Compose * * f g a -> Compose * * f g b

Bifunctor p => Invariant (WrappedBifunctor * * p a)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedBifunctor * * p a a -> WrappedBifunctor * * p a b

Invariant g => Invariant (Joker k * g a)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Joker k * g a a -> Joker k * g a b

Invariant2 p => Invariant (Flip * * p a)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Flip * * p a a -> Flip * * p a b

Invariant (Clown * k1 f a)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Clown * k1 f a a -> Clown * k1 f a b

Invariant m => Invariant (RWST r w s m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> RWST r w s m a -> RWST r w s m b

Invariant m => Invariant (RWST r w s m)

from the transformers package

Methods

invmap :: (a -> b) -> (b -> a) -> RWST r w s m a -> RWST r w s m b

Profunctor p => Invariant (WrappedProfunctor * * p a)

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedProfunctor * * p a a -> WrappedProfunctor * * p a b

(Invariant f, Invariant2 p) => Invariant (Tannen * * * f p a)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Tannen * * * f p a a -> Tannen * * * f p a b

(Invariant2 p, Invariant g) => Invariant (Biff * k1 * * p f g a)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> Biff * k1 * * p f g a a -> Biff * k1 * * p f g a b

invmapFunctor :: Functor f => (a -> b) -> (b -> a) -> f a -> f b

Every Functor is also an Invariant functor.

GHC.Generics

With GHC 7.2 or later, Invariant instances can be defined easily using GHC generics like so:

{-# LANGUAGE DeriveGeneric, FlexibleContexts #-}

import Data.Functor.Invariant
import GHC.Generics

data T f a = T (f a) deriving Generic1

instance Invariant f => Invariant (T f)

Be aware that generic Invariant instances cannot be derived for data types that have function arguments in which the last type parameter appears in a position other than the result type (e.g., data Fun a = Fun (a -> a)). For these, you can derive them using the Data.Functor.Invariant.TH module.

genericInvmap :: (Generic1 f, Invariant (Rep1 f)) => (a -> b) -> (b -> a) -> f a -> f b

A generic implementation of invmap.

newtype WrappedFunctor f a

Wrap a Functor to be used as a member of Invariant.

Constructors

WrapFunctor

Fields

• unwrapFunctor :: f a

Instances

Monad m => Monad (WrappedFunctor * m)

Methods

(>>=) :: WrappedFunctor * m a -> (a -> WrappedFunctor * m b) -> WrappedFunctor * m b

(>>) :: WrappedFunctor * m a -> WrappedFunctor * m b -> WrappedFunctor * m b

return :: a -> WrappedFunctor * m a

fail :: String -> WrappedFunctor * m a

Functor f => Functor (WrappedFunctor * f)

Methods

fmap :: (a -> b) -> WrappedFunctor * f a -> WrappedFunctor * f b

(<$) :: a -> WrappedFunctor * f b -> WrappedFunctor * f a

Applicative f => Applicative (WrappedFunctor * f)

Methods

pure :: a -> WrappedFunctor * f a

(<*>) :: WrappedFunctor * f (a -> b) -> WrappedFunctor * f a -> WrappedFunctor * f b

(*>) :: WrappedFunctor * f a -> WrappedFunctor * f b -> WrappedFunctor * f b

(<*) :: WrappedFunctor * f a -> WrappedFunctor * f b -> WrappedFunctor * f a

Foldable f => Foldable (WrappedFunctor * f)

Methods

fold :: Monoid m => WrappedFunctor * f m -> m

foldMap :: Monoid m => (a -> m) -> WrappedFunctor * f a -> m

foldr :: (a -> b -> b) -> b -> WrappedFunctor * f a -> b

foldr' :: (a -> b -> b) -> b -> WrappedFunctor * f a -> b

foldl :: (b -> a -> b) -> b -> WrappedFunctor * f a -> b

foldl' :: (b -> a -> b) -> b -> WrappedFunctor * f a -> b

foldr1 :: (a -> a -> a) -> WrappedFunctor * f a -> a

foldl1 :: (a -> a -> a) -> WrappedFunctor * f a -> a

toList :: WrappedFunctor * f a -> [a]

null :: WrappedFunctor * f a -> Bool

length :: WrappedFunctor * f a -> Int

elem :: Eq a => a -> WrappedFunctor * f a -> Bool

maximum :: Ord a => WrappedFunctor * f a -> a

minimum :: Ord a => WrappedFunctor * f a -> a

sum :: Num a => WrappedFunctor * f a -> a

product :: Num a => WrappedFunctor * f a -> a

Traversable f => Traversable (WrappedFunctor * f)

Methods

traverse :: Applicative f => (a -> f b) -> WrappedFunctor * f a -> f (WrappedFunctor * f b)

sequenceA :: Applicative f => WrappedFunctor * f (f a) -> f (WrappedFunctor * f a)

mapM :: Monad m => (a -> m b) -> WrappedFunctor * f a -> m (WrappedFunctor * f b)

sequence :: Monad m => WrappedFunctor * f (m a) -> m (WrappedFunctor * f a)

Alternative f => Alternative (WrappedFunctor * f)

Methods

empty :: WrappedFunctor * f a

(<|>) :: WrappedFunctor * f a -> WrappedFunctor * f a -> WrappedFunctor * f a

some :: WrappedFunctor * f a -> WrappedFunctor * f [a]

many :: WrappedFunctor * f a -> WrappedFunctor * f [a]

MonadPlus m => MonadPlus (WrappedFunctor * m)

Methods

mzero :: WrappedFunctor * m a

mplus :: WrappedFunctor * m a -> WrappedFunctor * m a -> WrappedFunctor * m a

Functor f => Invariant (WrappedFunctor * f)

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedFunctor * f a -> WrappedFunctor * f b

Eq (f a) => Eq (WrappedFunctor k f a)

Methods

(==) :: WrappedFunctor k f a -> WrappedFunctor k f a -> Bool

(/=) :: WrappedFunctor k f a -> WrappedFunctor k f a -> Bool

Ord (f a) => Ord (WrappedFunctor k f a)

Methods

compare :: WrappedFunctor k f a -> WrappedFunctor k f a -> Ordering

(<) :: WrappedFunctor k f a -> WrappedFunctor k f a -> Bool

(<=) :: WrappedFunctor k f a -> WrappedFunctor k f a -> Bool

(>) :: WrappedFunctor k f a -> WrappedFunctor k f a -> Bool

(>=) :: WrappedFunctor k f a -> WrappedFunctor k f a -> Bool

max :: WrappedFunctor k f a -> WrappedFunctor k f a -> WrappedFunctor k f a

min :: WrappedFunctor k f a -> WrappedFunctor k f a -> WrappedFunctor k f a

Read (f a) => Read (WrappedFunctor k f a)

Methods

readsPrec :: Int -> ReadS (WrappedFunctor k f a)

readList :: ReadS [WrappedFunctor k f a]

readPrec :: ReadPrec (WrappedFunctor k f a)

readListPrec :: ReadPrec [WrappedFunctor k f a]

Show (f a) => Show (WrappedFunctor k f a)

Methods

showsPrec :: Int -> WrappedFunctor k f a -> ShowS

show :: WrappedFunctor k f a -> String

showList :: [WrappedFunctor k f a] -> ShowS

invmapContravariant :: Contravariant f => (a -> b) -> (b -> a) -> f a -> f b

Every Contravariant functor is also an Invariant functor.

newtype WrappedContravariant f a

Wrap a Contravariant functor to be used as a member of Invariant.

Constructors

WrapContravariant

Fields

• unwrapContravariant :: f a

Instances

Divisible f => Divisible (WrappedContravariant * f)

Methods

divide :: (a -> (b, c)) -> WrappedContravariant * f b -> WrappedContravariant * f c -> WrappedContravariant * f a

conquer :: WrappedContravariant * f a

Decidable f => Decidable (WrappedContravariant * f)

Methods

lose :: (a -> Void) -> WrappedContravariant * f a

choose :: (a -> Either b c) -> WrappedContravariant * f b -> WrappedContravariant * f c -> WrappedContravariant * f a

Contravariant f => Contravariant (WrappedContravariant * f)

Methods

contramap :: (a -> b) -> WrappedContravariant * f b -> WrappedContravariant * f a

(>$) :: b -> WrappedContravariant * f b -> WrappedContravariant * f a

Contravariant f => Invariant (WrappedContravariant * f)

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedContravariant * f a -> WrappedContravariant * f b

Eq (f a) => Eq (WrappedContravariant k f a)

Methods

(==) :: WrappedContravariant k f a -> WrappedContravariant k f a -> Bool

(/=) :: WrappedContravariant k f a -> WrappedContravariant k f a -> Bool

Ord (f a) => Ord (WrappedContravariant k f a)

Methods

compare :: WrappedContravariant k f a -> WrappedContravariant k f a -> Ordering

(<) :: WrappedContravariant k f a -> WrappedContravariant k f a -> Bool

(<=) :: WrappedContravariant k f a -> WrappedContravariant k f a -> Bool

(>) :: WrappedContravariant k f a -> WrappedContravariant k f a -> Bool

(>=) :: WrappedContravariant k f a -> WrappedContravariant k f a -> Bool

max :: WrappedContravariant k f a -> WrappedContravariant k f a -> WrappedContravariant k f a

min :: WrappedContravariant k f a -> WrappedContravariant k f a -> WrappedContravariant k f a

Read (f a) => Read (WrappedContravariant k f a)

Methods

readsPrec :: Int -> ReadS (WrappedContravariant k f a)

readList :: ReadS [WrappedContravariant k f a]

readPrec :: ReadPrec (WrappedContravariant k f a)

readListPrec :: ReadPrec [WrappedContravariant k f a]

Show (f a) => Show (WrappedContravariant k f a)

Methods

showsPrec :: Int -> WrappedContravariant k f a -> ShowS

show :: WrappedContravariant k f a -> String

showList :: [WrappedContravariant k f a] -> ShowS

Invariant2

class Invariant2 f where

Any * -> * -> * type parametric in both arguments permits an instance of Invariant2.

Instances should satisfy the following laws:

invmap2 id id id id = id
invmap2 f2 f2' g2 g2' . invmap2 f1 f1' g1 g1' =
  invmap2 (f2 . f1) (f1' . f2') (g2 . g1) (g1' . g2')

Minimal complete definition

invmap2

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> f a b -> f c d

Instances

Invariant2 (->)

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> (a -> b) -> c -> d

Invariant2 Either

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Either a b -> Either c d

Invariant2 (,)

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> (a, b) -> (c, d)

Invariant2 Arg

from Data.Semigroup

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Arg a b -> Arg c d

Invariant2 Op

from the contravariant package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Op a b -> Op c d

Invariant2 (K1 i)

from GHC.Generics

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> K1 i a b -> K1 i c d

Invariant2 ((,,) a)

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> (a, a, b) -> (a, c, d)

Arrow arr => Invariant2 (WrappedArrow arr)

from Control.Applicative

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> WrappedArrow arr a b -> WrappedArrow arr c d

Monad m => Invariant2 (Kleisli m)

from Control.Arrow

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Kleisli m a b -> Kleisli m c d

Invariant2 (Const *)

from Control.Applicative

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Const * a b -> Const * c d

Comonad w => Invariant2 (Cokleisli w)

from the comonad package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Cokleisli w a b -> Cokleisli w c d

Invariant2 p => Invariant2 (Codensity p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Codensity p a b -> Codensity p c d

Invariant2 p => Invariant2 (CofreeMapping p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> CofreeMapping p a b -> CofreeMapping p c d

Invariant2 (FreeMapping p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> FreeMapping p a b -> FreeMapping p c d

Invariant2 p => Invariant2 (CofreeTraversing p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> CofreeTraversing p a b -> CofreeTraversing p c d

Invariant2 (FreeTraversing p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> FreeTraversing p a b -> FreeTraversing p c d

Invariant2 p => Invariant2 (Closure p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Closure p a b -> Closure p c d

Invariant2 (Environment p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Environment p a b -> Environment p c d

Invariant2 p => Invariant2 (TambaraSum p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> TambaraSum p a b -> TambaraSum p c d

Invariant2 (PastroSum p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> PastroSum p a b -> PastroSum p c d

Invariant2 (CotambaraSum p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> CotambaraSum p a b -> CotambaraSum p c d

Invariant2 (CopastroSum p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> CopastroSum p a b -> CopastroSum p c d

Invariant2 p => Invariant2 (Tambara p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Tambara p a b -> Tambara p c d

Invariant2 (Pastro p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Pastro p a b -> Pastro p c d

Invariant2 (Cotambara p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Cotambara p a b -> Cotambara p c d

Invariant f => Invariant2 (Star f)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Star f a b -> Star f c d

Invariant f => Invariant2 (Costar f)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Costar f a b -> Costar f c d

Arrow arr => Invariant2 (WrappedArrow arr)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> WrappedArrow arr a b -> WrappedArrow arr c d

Invariant2 (Forget r)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Forget r a b -> Forget r c d

Invariant2 (Tagged *)

from the tagged package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Tagged * a b -> Tagged * c d

Invariant2 (Constant *)

from the transformers package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Constant * a b -> Constant * c d

Invariant2 ((,,,) a b)

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> (a, b, a, b) -> (a, b, c, d)

(Invariant2 p, Invariant2 q) => Invariant2 (Ran p q)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Ran p q a b -> Ran p q c d

(Invariant2 p, Invariant2 q) => Invariant2 (Procompose p q)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Procompose p q a b -> Procompose p q c d

(Invariant2 p, Invariant2 q) => Invariant2 (Rift p q)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Rift p q a b -> Rift p q c d

(Invariant f, Invariant2 p) => Invariant2 (Cayley f p)

from the profunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Cayley f p a b -> Cayley f p c d

Invariant2 ((,,,,) a b c)

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> (a, b, c, a, b) -> (a, b, c, c, d)

Bifunctor p => Invariant2 (WrappedBifunctor * * p)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> WrappedBifunctor * * p a b -> WrappedBifunctor * * p c d

Invariant g => Invariant2 (Joker * * g)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Joker * * g a b -> Joker * * g c d

Invariant2 p => Invariant2 (Flip * * p)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Flip * * p a b -> Flip * * p c d

Invariant f => Invariant2 (Clown * * f)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Clown * * f a b -> Clown * * f c d

Profunctor p => Invariant2 (WrappedProfunctor * * p)

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> WrappedProfunctor * * p a b -> WrappedProfunctor * * p c d

(Invariant2 f, Invariant2 g) => Invariant2 (Product * * f g)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Product * * f g a b -> Product * * f g c d

(Invariant2 p, Invariant2 q) => Invariant2 (Sum * * p q)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Sum * * p q a b -> Sum * * p q c d

(Invariant f, Invariant2 p) => Invariant2 (Tannen * * * f p)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Tannen * * * f p a b -> Tannen * * * f p c d

(Invariant2 p, Invariant f, Invariant g) => Invariant2 (Biff * * * * p f g)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Biff * * * * p f g a b -> Biff * * * * p f g c d

invmap2Bifunctor :: Bifunctor f => (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> f a b -> f c d

Every Bifunctor is also an Invariant2 functor.

newtype WrappedBifunctor k k1 p a b :: forall k k1. (k1 -> k -> *) -> k1 -> k -> *

Make a Functor over the second argument of a Bifunctor.

Constructors

WrapBifunctor

Fields

• unwrapBifunctor :: p a b

Instances

Bifunctor p => Bifunctor (WrappedBifunctor * * p)

Methods

bimap :: (a -> b) -> (c -> d) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b d

first :: (a -> b) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b c

second :: (b -> c) -> WrappedBifunctor * * p a b -> WrappedBifunctor * * p a c

Biapplicative p => Biapplicative (WrappedBifunctor * * p)

Methods

bipure :: a -> b -> WrappedBifunctor * * p a b

(<<*>>) :: WrappedBifunctor * * p (a -> b) (c -> d) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b d

(*>>) :: WrappedBifunctor * * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p c d

(<<*) :: WrappedBifunctor * * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p a b

Bitraversable p => Bitraversable (WrappedBifunctor * * p)

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> WrappedBifunctor * * p a b -> f (WrappedBifunctor * * p c d)

Bifoldable p => Bifoldable (WrappedBifunctor * * p)

Methods

bifold :: Monoid m => WrappedBifunctor * * p m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> WrappedBifunctor * * p a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> WrappedBifunctor * * p a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> WrappedBifunctor * * p a b -> c

Bifunctor p => Invariant2 (WrappedBifunctor * * p)

from the bifunctors package

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> WrappedBifunctor * * p a b -> WrappedBifunctor * * p c d

Bifunctor p => Functor (WrappedBifunctor * * p a)

Methods

fmap :: (a -> b) -> WrappedBifunctor * * p a a -> WrappedBifunctor * * p a b

(<$) :: a -> WrappedBifunctor * * p a b -> WrappedBifunctor * * p a a

Bifoldable p => Foldable (WrappedBifunctor * * p a)

Methods

fold :: Monoid m => WrappedBifunctor * * p a m -> m

foldMap :: Monoid m => (a -> m) -> WrappedBifunctor * * p a a -> m

foldr :: (a -> b -> b) -> b -> WrappedBifunctor * * p a a -> b

foldr' :: (a -> b -> b) -> b -> WrappedBifunctor * * p a a -> b

foldl :: (b -> a -> b) -> b -> WrappedBifunctor * * p a a -> b

foldl' :: (b -> a -> b) -> b -> WrappedBifunctor * * p a a -> b

foldr1 :: (a -> a -> a) -> WrappedBifunctor * * p a a -> a

foldl1 :: (a -> a -> a) -> WrappedBifunctor * * p a a -> a

toList :: WrappedBifunctor * * p a a -> [a]

null :: WrappedBifunctor * * p a a -> Bool

length :: WrappedBifunctor * * p a a -> Int

elem :: Eq a => a -> WrappedBifunctor * * p a a -> Bool

maximum :: Ord a => WrappedBifunctor * * p a a -> a

minimum :: Ord a => WrappedBifunctor * * p a a -> a

sum :: Num a => WrappedBifunctor * * p a a -> a

product :: Num a => WrappedBifunctor * * p a a -> a

Bitraversable p => Traversable (WrappedBifunctor * * p a)

Methods

traverse :: Applicative f => (a -> f b) -> WrappedBifunctor * * p a a -> f (WrappedBifunctor * * p a b)

sequenceA :: Applicative f => WrappedBifunctor * * p a (f a) -> f (WrappedBifunctor * * p a a)

mapM :: Monad m => (a -> m b) -> WrappedBifunctor * * p a a -> m (WrappedBifunctor * * p a b)

sequence :: Monad m => WrappedBifunctor * * p a (m a) -> m (WrappedBifunctor * * p a a)

Generic1 (WrappedBifunctor * k p a)

Associated Types

type Rep1 (WrappedBifunctor * k p a :: * -> *) :: * -> *

Methods

from1 :: WrappedBifunctor * k p a a -> Rep1 (WrappedBifunctor * k p a) a

to1 :: Rep1 (WrappedBifunctor * k p a) a -> WrappedBifunctor * k p a a

Bifunctor p => Invariant (WrappedBifunctor * * p a)

from the bifunctors package

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedBifunctor * * p a a -> WrappedBifunctor * * p a b

Eq (p a b) => Eq (WrappedBifunctor k1 k p a b)

Methods

(==) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool

(/=) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool

Ord (p a b) => Ord (WrappedBifunctor k1 k p a b)

Methods

compare :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Ordering

(<) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool

(<=) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool

(>) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool

(>=) :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> Bool

max :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b

min :: WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b -> WrappedBifunctor k1 k p a b

Read (p a b) => Read (WrappedBifunctor k1 k p a b)

Methods

readsPrec :: Int -> ReadS (WrappedBifunctor k1 k p a b)

readList :: ReadS [WrappedBifunctor k1 k p a b]

readPrec :: ReadPrec (WrappedBifunctor k1 k p a b)

readListPrec :: ReadPrec [WrappedBifunctor k1 k p a b]

Show (p a b) => Show (WrappedBifunctor k1 k p a b)

Methods

showsPrec :: Int -> WrappedBifunctor k1 k p a b -> ShowS

show :: WrappedBifunctor k1 k p a b -> String

showList :: [WrappedBifunctor k1 k p a b] -> ShowS

Generic (WrappedBifunctor k1 k p a b)

Associated Types

type Rep (WrappedBifunctor k1 k p a b) :: * -> *

Methods

from :: WrappedBifunctor k1 k p a b -> Rep (WrappedBifunctor k1 k p a b) x

to :: Rep (WrappedBifunctor k1 k p a b) x -> WrappedBifunctor k1 k p a b

type Rep1 (WrappedBifunctor * k p a)

type Rep1 (WrappedBifunctor * k p a) = D1 (MetaData "WrappedBifunctor" "Data.Bifunctor.Wrapped" "bifunctors-5.4.2-FZrmj8WklPbIT4LBQhjbnY" True) (C1 (MetaCons "WrapBifunctor" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapBifunctor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (p a))))

type Rep (WrappedBifunctor k1 k p a b)

type Rep (WrappedBifunctor k1 k p a b) = D1 (MetaData "WrappedBifunctor" "Data.Bifunctor.Wrapped" "bifunctors-5.4.2-FZrmj8WklPbIT4LBQhjbnY" True) (C1 (MetaCons "WrapBifunctor" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapBifunctor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (p a b))))

invmap2Profunctor :: Profunctor f => (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> f a b -> f c d

Every Profunctor is also an Invariant2 functor.

newtype WrappedProfunctor p a b

Wrap a Profunctor to be used as a member of Invariant2.

Constructors

WrapProfunctor

Fields

• unwrapProfunctor :: p a b

Instances

Category k p => Category k (WrappedProfunctor k k p)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

ProfunctorFunctor (WrappedProfunctor * *)

Methods

promap :: Profunctor p => (p :-> q) -> WrappedProfunctor * * p :-> WrappedProfunctor * * q

ProfunctorMonad (WrappedProfunctor * *)

Methods

proreturn :: Profunctor p => p :-> WrappedProfunctor * * p

projoin :: Profunctor p => WrappedProfunctor * * (WrappedProfunctor * * p) :-> WrappedProfunctor * * p

ProfunctorComonad (WrappedProfunctor * *)

Methods

proextract :: Profunctor p => WrappedProfunctor * * p :-> p

produplicate :: Profunctor p => WrappedProfunctor * * p :-> WrappedProfunctor * * (WrappedProfunctor * * p)

Arrow p => Arrow (WrappedProfunctor * * p)

Methods

arr :: (b -> c) -> WrappedProfunctor * * p b c

first :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p (b, d) (c, d)

second :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p (d, b) (d, c)

(***) :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p b' c' -> WrappedProfunctor * * p (b, b') (c, c')

(&&&) :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p b c' -> WrappedProfunctor * * p b (c, c')

ArrowZero p => ArrowZero (WrappedProfunctor * * p)

Methods

zeroArrow :: WrappedProfunctor * * p b c

ArrowPlus p => ArrowPlus (WrappedProfunctor * * p)

Methods

(<+>) :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p b c -> WrappedProfunctor * * p b c

ArrowChoice p => ArrowChoice (WrappedProfunctor * * p)

Methods

left :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p (Either b d) (Either c d)

right :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p (Either d b) (Either d c)

(+++) :: WrappedProfunctor * * p b c -> WrappedProfunctor * * p b' c' -> WrappedProfunctor * * p (Either b b') (Either c c')

(|||) :: WrappedProfunctor * * p b d -> WrappedProfunctor * * p c d -> WrappedProfunctor * * p (Either b c) d

ArrowLoop p => ArrowLoop (WrappedProfunctor * * p)

Methods

loop :: WrappedProfunctor * * p (b, d) (c, d) -> WrappedProfunctor * * p b c

Mapping p => Mapping (WrappedProfunctor * * p)

Methods

map' :: Functor f => WrappedProfunctor * * p a b -> WrappedProfunctor * * p (f a) (f b)

Traversing p => Traversing (WrappedProfunctor * * p)

Methods

traverse' :: Traversable f => WrappedProfunctor * * p a b -> WrappedProfunctor * * p (f a) (f b)

wander :: (forall f. Applicative f => (a -> f b) -> s -> f t) -> WrappedProfunctor * * p a b -> WrappedProfunctor * * p s t

Closed p => Closed (WrappedProfunctor * * p)

Methods

closed :: WrappedProfunctor * * p a b -> WrappedProfunctor * * p (x -> a) (x -> b)

Choice p => Choice (WrappedProfunctor * * p)

Methods

left' :: WrappedProfunctor * * p a b -> WrappedProfunctor * * p (Either a c) (Either b c)

right' :: WrappedProfunctor * * p a b -> WrappedProfunctor * * p (Either c a) (Either c b)

Cochoice p => Cochoice (WrappedProfunctor * * p)

Methods

unleft :: WrappedProfunctor * * p (Either a d) (Either b d) -> WrappedProfunctor * * p a b

unright :: WrappedProfunctor * * p (Either d a) (Either d b) -> WrappedProfunctor * * p a b

Strong p => Strong (WrappedProfunctor * * p)

Methods

first' :: WrappedProfunctor * * p a b -> WrappedProfunctor * * p (a, c) (b, c)

second' :: WrappedProfunctor * * p a b -> WrappedProfunctor * * p (c, a) (c, b)

Costrong p => Costrong (WrappedProfunctor * * p)

Methods

unfirst :: WrappedProfunctor * * p (a, d) (b, d) -> WrappedProfunctor * * p a b

unsecond :: WrappedProfunctor * * p (d, a) (d, b) -> WrappedProfunctor * * p a b

Profunctor p => Profunctor (WrappedProfunctor * * p)

Methods

dimap :: (a -> b) -> (c -> d) -> WrappedProfunctor * * p b c -> WrappedProfunctor * * p a d

lmap :: (a -> b) -> WrappedProfunctor * * p b c -> WrappedProfunctor * * p a c

rmap :: (b -> c) -> WrappedProfunctor * * p a b -> WrappedProfunctor * * p a c

(#.) :: Coercible * c b => (b -> c) -> WrappedProfunctor * * p a b -> WrappedProfunctor * * p a c

(.#) :: Coercible * b a => WrappedProfunctor * * p b c -> (a -> b) -> WrappedProfunctor * * p a c

Profunctor p => Invariant2 (WrappedProfunctor * * p)

Methods

invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> WrappedProfunctor * * p a b -> WrappedProfunctor * * p c d

Profunctor p => Invariant (WrappedProfunctor * * p a)

Methods

invmap :: (a -> b) -> (b -> a) -> WrappedProfunctor * * p a a -> WrappedProfunctor * * p a b

Eq (p a b) => Eq (WrappedProfunctor k1 k p a b)

Methods

(==) :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> Bool

(/=) :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> Bool

Ord (p a b) => Ord (WrappedProfunctor k1 k p a b)

Methods

compare :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> Ordering

(<) :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> Bool

(<=) :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> Bool

(>) :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> Bool

(>=) :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> Bool

max :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b

min :: WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b -> WrappedProfunctor k1 k p a b

Read (p a b) => Read (WrappedProfunctor k1 k p a b)

Methods

readsPrec :: Int -> ReadS (WrappedProfunctor k1 k p a b)

readList :: ReadS [WrappedProfunctor k1 k p a b]

readPrec :: ReadPrec (WrappedProfunctor k1 k p a b)

readListPrec :: ReadPrec [WrappedProfunctor k1 k p a b]

Show (p a b) => Show (WrappedProfunctor k1 k p a b)

Methods

showsPrec :: Int -> WrappedProfunctor k1 k p a b -> ShowS

show :: WrappedProfunctor k1 k p a b -> String

showList :: [WrappedProfunctor k1 k p a b] -> ShowS