Data.Functor.Module

LeftModule

class LeftModule cat t1 f where

Methods

lstrength :: cat (f a) (f (t1 a x))

Examples

>>> :t lstrength @(->) @(,) @Predicate (Predicate @Int (> 10))
lstrength @(->) @(,) @Predicate (Predicate @Int (> 10)) :: Predicate (Int, x)

>>> :t lstrength @(->) @Either @[]
lstrength @(->) @Either @[] :: a -> [Either a x]

>>> lstrength @(->) @Either @[] [True, False]
[Left True,Left False]

Instances

LeftModule Op Either Comparison

Defined in Data.Functor.Module

Methods

lstrength :: Op (Comparison a) (Comparison (Either a x))

LeftModule Op Either Equivalence

Defined in Data.Functor.Module

Methods

lstrength :: Op (Equivalence a) (Equivalence (Either a x))

LeftModule Op Either Predicate

Defined in Data.Functor.Module

Methods

lstrength :: Op (Predicate a) (Predicate (Either a x))

LeftModule Op (,) ZipList

Defined in Data.Functor.Module

Methods

lstrength :: Op (ZipList a) (ZipList (a, x))

LeftModule Op (,) Identity

Defined in Data.Functor.Module

Methods

lstrength :: Op (Identity a) (Identity (a, x))

LeftModule Op (,) IO

Defined in Data.Functor.Module

Methods

lstrength :: Op (IO a) (IO (a, x))

LeftModule Op (,) NonEmpty

Defined in Data.Functor.Module

Methods

lstrength :: Op (NonEmpty a) (NonEmpty (a, x))

LeftModule Op (,) Maybe

Defined in Data.Functor.Module

Methods

lstrength :: Op (Maybe a) (Maybe (a, x))

LeftModule Op (,) []

Defined in Data.Functor.Module

Methods

lstrength :: Op [a] [(a, x)]

LeftModule Op Either (Op a)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Op a a0) (Op a (Either a0 x))

LeftModule Op Either (Proxy :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Proxy a) (Proxy (Either a x))

LeftModule Op Either (U1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: Op (U1 a) (U1 (Either a x))

LeftModule Op Either (V1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: Op (V1 a) (V1 (Either a x))

LeftModule Op (,) (Either e)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Either e a) (Either e (a, x))

LeftModule Op (,) ((,) x1)

Defined in Data.Functor.Module

Methods

lstrength :: Op (x1, a) (x1, (a, x))

LeftModule Op Either (Const a :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Const a a0) (Const a (Either a0 x))

Contravariant f => LeftModule Op Either (Alt f)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Alt f a) (Alt f (Either a x))

Contravariant f => LeftModule Op Either (Rec1 f)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Rec1 f a) (Rec1 f (Either a x))

LeftModule Op (,) ((,,) x1 x2)

Defined in Data.Functor.Module

Methods

lstrength :: Op (x1, x2, a) (x1, x2, (a, x))

(Contravariant f, Contravariant g) => LeftModule Op Either (Product f g)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Product f g a) (Product f g (Either a x))

(Contravariant f, Contravariant g) => LeftModule Op Either (Sum f g)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Sum f g a) (Sum f g (Either a x))

(Contravariant f, Contravariant g) => LeftModule Op Either (f :*: g)

Defined in Data.Functor.Module

Methods

lstrength :: Op ((f :*: g) a) ((f :*: g) (Either a x))

(Contravariant f, Contravariant g) => LeftModule Op Either (f :+: g)

Defined in Data.Functor.Module

Methods

lstrength :: Op ((f :+: g) a) ((f :+: g) (Either a x))

LeftModule Op Either (K1 i c :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: Op (K1 i c a) (K1 i c (Either a x))

(Functor f, Functor g) => LeftModule Op (,) (Product f g)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Product f g a) (Product f g (a, x))

(Functor f, Functor g) => LeftModule Op (,) (Sum f g)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Sum f g a) (Sum f g (a, x))

LeftModule Op (,) ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

Methods

lstrength :: Op (x1, x2, x3, a) (x1, x2, x3, (a, x))

(Functor f, Contravariant g) => LeftModule Op Either (Compose f g)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Compose f g a) (Compose f g (Either a x))

(Functor f, Contravariant g) => LeftModule Op Either (f :.: g)

Defined in Data.Functor.Module

Methods

lstrength :: Op ((f :.: g) a) ((f :.: g) (Either a x))

Contravariant f => LeftModule Op Either (M1 i c f)

Defined in Data.Functor.Module

Methods

lstrength :: Op (M1 i c f a) (M1 i c f (Either a x))

(Functor f, Functor g) => LeftModule Op (,) (Compose f g)

Defined in Data.Functor.Module

Methods

lstrength :: Op (Compose f g a) (Compose f g (a, x))

LeftModule (->) Either ZipList

Defined in Data.Functor.Module

Methods

lstrength :: ZipList a -> ZipList (Either a x)

LeftModule (->) Either Identity

Defined in Data.Functor.Module

Methods

lstrength :: Identity a -> Identity (Either a x)

LeftModule (->) Either IO

Defined in Data.Functor.Module

Methods

lstrength :: IO a -> IO (Either a x)

LeftModule (->) Either NonEmpty

Defined in Data.Functor.Module

Methods

lstrength :: NonEmpty a -> NonEmpty (Either a x)

LeftModule (->) Either Maybe

Defined in Data.Functor.Module

Methods

lstrength :: Maybe a -> Maybe (Either a x)

LeftModule (->) Either []

Defined in Data.Functor.Module

Methods

lstrength :: [a] -> [Either a x]

LeftModule (->) These ZipList

Defined in Data.Functor.Module

Methods

lstrength :: ZipList a -> ZipList (These a x)

LeftModule (->) These Identity

Defined in Data.Functor.Module

Methods

lstrength :: Identity a -> Identity (These a x)

LeftModule (->) These IO

Defined in Data.Functor.Module

Methods

lstrength :: IO a -> IO (These a x)

LeftModule (->) These NonEmpty

Defined in Data.Functor.Module

Methods

lstrength :: NonEmpty a -> NonEmpty (These a x)

LeftModule (->) These Maybe

Defined in Data.Functor.Module

Methods

lstrength :: Maybe a -> Maybe (These a x)

LeftModule (->) These []

Defined in Data.Functor.Module

Methods

lstrength :: [a] -> [These a x]

LeftModule (->) (,) Comparison

Defined in Data.Functor.Module

Methods

lstrength :: Comparison a -> Comparison (a, x)

LeftModule (->) (,) Equivalence

Defined in Data.Functor.Module

Methods

lstrength :: Equivalence a -> Equivalence (a, x)

LeftModule (->) (,) Predicate

Defined in Data.Functor.Module

Methods

lstrength :: Predicate a -> Predicate (a, x)

LeftModule (->) Either (Either e)

Defined in Data.Functor.Module

Methods

lstrength :: Either e a -> Either e (Either a x)

LeftModule (->) Either (These a)

Defined in Data.Functor.Module

Methods

lstrength :: These a a0 -> These a (Either a0 x)

LeftModule (->) Either ((,) x1)

Defined in Data.Functor.Module

Methods

lstrength :: (x1, a) -> (x1, Either a x)

LeftModule (->) These (Either e)

Defined in Data.Functor.Module

Methods

lstrength :: Either e a -> Either e (These a x)

LeftModule (->) These (These a)

Defined in Data.Functor.Module

Methods

lstrength :: These a a0 -> These a (These a0 x)

LeftModule (->) These ((,) x1)

Defined in Data.Functor.Module

Methods

lstrength :: (x1, a) -> (x1, These a x)

LeftModule (->) (,) (Op a)

Defined in Data.Functor.Module

Methods

lstrength :: Op a a0 -> Op a (a0, x)

LeftModule (->) (,) (Proxy :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: Proxy a -> Proxy (a, x)

LeftModule (->) (,) (U1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: U1 a -> U1 (a, x)

LeftModule (->) (,) (V1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: V1 a -> V1 (a, x)

LeftModule (->) Either ((,,) x1 x2)

Defined in Data.Functor.Module

Methods

lstrength :: (x1, x2, a) -> (x1, x2, Either a x)

LeftModule (->) These ((,,) x1 x2)

Defined in Data.Functor.Module

Methods

lstrength :: (x1, x2, a) -> (x1, x2, These a x)

LeftModule (->) (,) (Const a :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: Const a a0 -> Const a (a0, x)

Contravariant f => LeftModule (->) (,) (Alt f)

Defined in Data.Functor.Module

Methods

lstrength :: Alt f a -> Alt f (a, x)

Contravariant f => LeftModule (->) (,) (Rec1 f)

Defined in Data.Functor.Module

Methods

lstrength :: Rec1 f a -> Rec1 f (a, x)

(Functor f, Functor g) => LeftModule (->) Either (Product f g)

Defined in Data.Functor.Module

Methods

lstrength :: Product f g a -> Product f g (Either a x)

(Functor f, Functor g) => LeftModule (->) Either (Sum f g)

Defined in Data.Functor.Module

Methods

lstrength :: Sum f g a -> Sum f g (Either a x)

LeftModule (->) Either ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

Methods

lstrength :: (x1, x2, x3, a) -> (x1, x2, x3, Either a x)

(Functor f, Functor g) => LeftModule (->) These (Product f g)

Defined in Data.Functor.Module

Methods

lstrength :: Product f g a -> Product f g (These a x)

(Functor f, Functor g) => LeftModule (->) These (Sum f g)

Defined in Data.Functor.Module

Methods

lstrength :: Sum f g a -> Sum f g (These a x)

LeftModule (->) These ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

Methods

lstrength :: (x1, x2, x3, a) -> (x1, x2, x3, These a x)

(Contravariant f, Contravariant g) => LeftModule (->) (,) (Product f g)

Defined in Data.Functor.Module

Methods

lstrength :: Product f g a -> Product f g (a, x)

(Contravariant f, Contravariant g) => LeftModule (->) (,) (Sum f g)

Defined in Data.Functor.Module

Methods

lstrength :: Sum f g a -> Sum f g (a, x)

(Contravariant f, Contravariant g) => LeftModule (->) (,) (f :*: g)

Defined in Data.Functor.Module

Methods

lstrength :: (f :*: g) a -> (f :*: g) (a, x)

(Contravariant f, Contravariant g) => LeftModule (->) (,) (f :+: g)

Defined in Data.Functor.Module

Methods

lstrength :: (f :+: g) a -> (f :+: g) (a, x)

LeftModule (->) (,) (K1 i c :: Type -> Type)

Defined in Data.Functor.Module

Methods

lstrength :: K1 i c a -> K1 i c (a, x)

(Functor f, Functor g) => LeftModule (->) Either (Compose f g)

Defined in Data.Functor.Module

Methods

lstrength :: Compose f g a -> Compose f g (Either a x)

(Functor f, Functor g) => LeftModule (->) These (Compose f g)

Defined in Data.Functor.Module

Methods

lstrength :: Compose f g a -> Compose f g (These a x)

(Functor f, Contravariant g) => LeftModule (->) (,) (Compose f g)

Defined in Data.Functor.Module

Methods

lstrength :: Compose f g a -> Compose f g (a, x)

(Functor f, Contravariant g) => LeftModule (->) (,) (f :.: g)

Defined in Data.Functor.Module

Methods

lstrength :: (f :.: g) a -> (f :.: g) (a, x)

Contravariant f => LeftModule (->) (,) (M1 i c f)

Defined in Data.Functor.Module

Methods

lstrength :: M1 i c f a -> M1 i c f (a, x)

RightModule

class RightModule cat t1 f where

Methods

rstrength :: cat (f a) (f (t1 x a))

Examples

>>> :t rstrength @(->) @(,) @Predicate (Predicate @Int (> 10))
rstrength @(->) @(,) @Predicate (Predicate @Int (> 10)) :: Predicate (x, Int)

>>> :t rstrength @(->) @Either @[]
rstrength @(->) @Either @[] :: [a] -> [Either x a]
>>> rstrength @(->) @Either @[] [True, False]
[Right True,Right False]

Instances

RightModule Op Either Comparison

Defined in Data.Functor.Module

Methods

rstrength :: Op (Comparison a) (Comparison (Either x a))

RightModule Op Either Equivalence

Defined in Data.Functor.Module

Methods

rstrength :: Op (Equivalence a) (Equivalence (Either x a))

RightModule Op Either Predicate

Defined in Data.Functor.Module

Methods

rstrength :: Op (Predicate a) (Predicate (Either x a))

RightModule Op (,) ZipList

Defined in Data.Functor.Module

Methods

rstrength :: Op (ZipList a) (ZipList (x, a))

RightModule Op (,) Identity

Defined in Data.Functor.Module

Methods

rstrength :: Op (Identity a) (Identity (x, a))

RightModule Op (,) IO

Defined in Data.Functor.Module

Methods

rstrength :: Op (IO a) (IO (x, a))

RightModule Op (,) NonEmpty

Defined in Data.Functor.Module

Methods

rstrength :: Op (NonEmpty a) (NonEmpty (x, a))

RightModule Op (,) Maybe

Defined in Data.Functor.Module

Methods

rstrength :: Op (Maybe a) (Maybe (x, a))

RightModule Op (,) []

Defined in Data.Functor.Module

Methods

rstrength :: Op [a] [(x, a)]

RightModule Op Either (Op a)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Op a a0) (Op a (Either x a0))

RightModule Op Either (Proxy :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Proxy a) (Proxy (Either x a))

RightModule Op Either (U1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: Op (U1 a) (U1 (Either x a))

RightModule Op Either (V1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: Op (V1 a) (V1 (Either x a))

RightModule Op (,) (Either e)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Either e a) (Either e (x, a))

RightModule Op (,) ((,) x1)

Defined in Data.Functor.Module

Methods

rstrength :: Op (x1, a) (x1, (x, a))

RightModule Op Either (Const a :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Const a a0) (Const a (Either x a0))

Contravariant f => RightModule Op Either (Alt f)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Alt f a) (Alt f (Either x a))

Contravariant f => RightModule Op Either (Rec1 f)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Rec1 f a) (Rec1 f (Either x a))

RightModule Op (,) ((,,) x1 x2)

Defined in Data.Functor.Module

Methods

rstrength :: Op (x1, x2, a) (x1, x2, (x, a))

(Contravariant f, Contravariant g) => RightModule Op Either (Product f g)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Product f g a) (Product f g (Either x a))

(Contravariant f, Contravariant g) => RightModule Op Either (Sum f g)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Sum f g a) (Sum f g (Either x a))

(Contravariant f, Contravariant g) => RightModule Op Either (f :*: g)

Defined in Data.Functor.Module

Methods

rstrength :: Op ((f :*: g) a) ((f :*: g) (Either x a))

(Contravariant f, Contravariant g) => RightModule Op Either (f :+: g)

Defined in Data.Functor.Module

Methods

rstrength :: Op ((f :+: g) a) ((f :+: g) (Either x a))

RightModule Op Either (K1 i c :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: Op (K1 i c a) (K1 i c (Either x a))

(Functor f, Functor g) => RightModule Op (,) (Product f g)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Product f g a) (Product f g (x, a))

(Functor f, Functor g) => RightModule Op (,) (Sum f g)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Sum f g a) (Sum f g (x, a))

RightModule Op (,) ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

Methods

rstrength :: Op (x1, x2, x3, a) (x1, x2, x3, (x, a))

(Functor f, Contravariant g) => RightModule Op Either (Compose f g)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Compose f g a) (Compose f g (Either x a))

(Functor f, Contravariant g) => RightModule Op Either (f :.: g)

Defined in Data.Functor.Module

Methods

rstrength :: Op ((f :.: g) a) ((f :.: g) (Either x a))

Contravariant f => RightModule Op Either (M1 i c f)

Defined in Data.Functor.Module

Methods

rstrength :: Op (M1 i c f a) (M1 i c f (Either x a))

(Functor f, Functor g) => RightModule Op (,) (Compose f g)

Defined in Data.Functor.Module

Methods

rstrength :: Op (Compose f g a) (Compose f g (x, a))

RightModule (->) Either ZipList

Defined in Data.Functor.Module

Methods

rstrength :: ZipList a -> ZipList (Either x a)

RightModule (->) Either Identity

Defined in Data.Functor.Module

Methods

rstrength :: Identity a -> Identity (Either x a)

RightModule (->) Either IO

Defined in Data.Functor.Module

Methods

rstrength :: IO a -> IO (Either x a)

RightModule (->) Either NonEmpty

Defined in Data.Functor.Module

Methods

rstrength :: NonEmpty a -> NonEmpty (Either x a)

RightModule (->) Either Maybe

Defined in Data.Functor.Module

Methods

rstrength :: Maybe a -> Maybe (Either x a)

RightModule (->) Either []

Defined in Data.Functor.Module

Methods

rstrength :: [a] -> [Either x a]

RightModule (->) These ZipList

Defined in Data.Functor.Module

Methods

rstrength :: ZipList a -> ZipList (These x a)

RightModule (->) These Identity

Defined in Data.Functor.Module

Methods

rstrength :: Identity a -> Identity (These x a)

RightModule (->) These IO

Defined in Data.Functor.Module

Methods

rstrength :: IO a -> IO (These x a)

RightModule (->) These NonEmpty

Defined in Data.Functor.Module

Methods

rstrength :: NonEmpty a -> NonEmpty (These x a)

RightModule (->) These Maybe

Defined in Data.Functor.Module

Methods

rstrength :: Maybe a -> Maybe (These x a)

RightModule (->) These []

Defined in Data.Functor.Module

Methods

rstrength :: [a] -> [These x a]

RightModule (->) (,) Comparison

Defined in Data.Functor.Module

Methods

rstrength :: Comparison a -> Comparison (x, a)

RightModule (->) (,) Equivalence

Defined in Data.Functor.Module

Methods

rstrength :: Equivalence a -> Equivalence (x, a)

RightModule (->) (,) Predicate

Defined in Data.Functor.Module

Methods

rstrength :: Predicate a -> Predicate (x, a)

RightModule (->) Either (Either e)

Defined in Data.Functor.Module

Methods

rstrength :: Either e a -> Either e (Either x a)

RightModule (->) Either (These a)

Defined in Data.Functor.Module

Methods

rstrength :: These a a0 -> These a (Either x a0)

RightModule (->) Either ((,) x1)

Defined in Data.Functor.Module

Methods

rstrength :: (x1, a) -> (x1, Either x a)

RightModule (->) These (Either e)

Defined in Data.Functor.Module

Methods

rstrength :: Either e a -> Either e (These x a)

RightModule (->) These (These a)

Defined in Data.Functor.Module

Methods

rstrength :: These a a0 -> These a (These x a0)

RightModule (->) These ((,) x1)

Defined in Data.Functor.Module

Methods

rstrength :: (x1, a) -> (x1, These x a)

RightModule (->) (,) (Op a)

Defined in Data.Functor.Module

Methods

rstrength :: Op a a0 -> Op a (x, a0)

RightModule (->) (,) (Proxy :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: Proxy a -> Proxy (x, a)

RightModule (->) (,) (U1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: U1 a -> U1 (x, a)

RightModule (->) (,) (V1 :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: V1 a -> V1 (x, a)

RightModule (->) Either ((,,) x1 x2)

Defined in Data.Functor.Module

Methods

rstrength :: (x1, x2, a) -> (x1, x2, Either x a)

RightModule (->) These ((,,) x1 x2)

Defined in Data.Functor.Module

Methods

rstrength :: (x1, x2, a) -> (x1, x2, These x a)

RightModule (->) (,) (Const a :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: Const a a0 -> Const a (x, a0)

Contravariant f => RightModule (->) (,) (Alt f)

Defined in Data.Functor.Module

Methods

rstrength :: Alt f a -> Alt f (x, a)

Contravariant f => RightModule (->) (,) (Rec1 f)

Defined in Data.Functor.Module

Methods

rstrength :: Rec1 f a -> Rec1 f (x, a)

(Functor f, Functor g) => RightModule (->) Either (Product f g)

Defined in Data.Functor.Module

Methods

rstrength :: Product f g a -> Product f g (Either x a)

(Functor f, Functor g) => RightModule (->) Either (Sum f g)

Defined in Data.Functor.Module

Methods

rstrength :: Sum f g a -> Sum f g (Either x a)

RightModule (->) Either ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

Methods

rstrength :: (x1, x2, x3, a) -> (x1, x2, x3, Either x a)

(Functor f, Functor g) => RightModule (->) These (Product f g)

Defined in Data.Functor.Module

Methods

rstrength :: Product f g a -> Product f g (These x a)

(Functor f, Functor g) => RightModule (->) These (Sum f g)

Defined in Data.Functor.Module

Methods

rstrength :: Sum f g a -> Sum f g (These x a)

RightModule (->) These ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

Methods

rstrength :: (x1, x2, x3, a) -> (x1, x2, x3, These x a)

(Contravariant f, Contravariant g) => RightModule (->) (,) (Product f g)

Defined in Data.Functor.Module

Methods

rstrength :: Product f g a -> Product f g (x, a)

(Contravariant f, Contravariant g) => RightModule (->) (,) (Sum f g)

Defined in Data.Functor.Module

Methods

rstrength :: Sum f g a -> Sum f g (x, a)

(Contravariant f, Contravariant g) => RightModule (->) (,) (f :*: g)

Defined in Data.Functor.Module

Methods

rstrength :: (f :*: g) a -> (f :*: g) (x, a)

(Contravariant f, Contravariant g) => RightModule (->) (,) (f :+: g)

Defined in Data.Functor.Module

Methods

rstrength :: (f :+: g) a -> (f :+: g) (x, a)

RightModule (->) (,) (K1 i c :: Type -> Type)

Defined in Data.Functor.Module

Methods

rstrength :: K1 i c a -> K1 i c (x, a)

(Functor f, Functor g) => RightModule (->) Either (Compose f g)

Defined in Data.Functor.Module

Methods

rstrength :: Compose f g a -> Compose f g (Either x a)

(Functor f, Functor g) => RightModule (->) These (Compose f g)

Defined in Data.Functor.Module

Methods

rstrength :: Compose f g a -> Compose f g (These x a)

(Functor f, Contravariant g) => RightModule (->) (,) (Compose f g)

Defined in Data.Functor.Module

Methods

rstrength :: Compose f g a -> Compose f g (x, a)

(Functor f, Contravariant g) => RightModule (->) (,) (f :.: g)

Defined in Data.Functor.Module

Methods

rstrength :: (f :.: g) a -> (f :.: g) (x, a)

Contravariant f => RightModule (->) (,) (M1 i c f)

Defined in Data.Functor.Module

Methods

rstrength :: M1 i c f a -> M1 i c f (x, a)

Bimodule

class (LeftModule cat t1 f, RightModule cat t1 f) => Bimodule cat t1 f

Instances

Bimodule Op Either Comparison

Defined in Data.Functor.Module

Bimodule Op Either Equivalence

Defined in Data.Functor.Module

Bimodule Op Either Predicate

Defined in Data.Functor.Module

Bimodule Op (,) ZipList

Defined in Data.Functor.Module

Bimodule Op (,) Identity

Defined in Data.Functor.Module

Bimodule Op (,) IO

Defined in Data.Functor.Module

Bimodule Op (,) NonEmpty

Defined in Data.Functor.Module

Bimodule Op (,) Maybe

Defined in Data.Functor.Module

Bimodule Op (,) []

Defined in Data.Functor.Module

Bimodule Op Either (Op a)

Defined in Data.Functor.Module

Bimodule Op Either (Proxy :: Type -> Type)

Defined in Data.Functor.Module

Bimodule Op Either (U1 :: Type -> Type)

Defined in Data.Functor.Module

Bimodule Op Either (V1 :: Type -> Type)

Defined in Data.Functor.Module

Bimodule Op (,) (Either e)

Defined in Data.Functor.Module

Bimodule Op (,) ((,) x1)

Defined in Data.Functor.Module

Bimodule Op Either (Const a :: Type -> Type)

Defined in Data.Functor.Module

Contravariant f => Bimodule Op Either (Alt f)

Defined in Data.Functor.Module

Contravariant f => Bimodule Op Either (Rec1 f)

Defined in Data.Functor.Module

Bimodule Op (,) ((,,) x1 x2)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule Op Either (Product f g)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule Op Either (Sum f g)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule Op Either (f :*: g)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule Op Either (f :+: g)

Defined in Data.Functor.Module

Bimodule Op Either (K1 i c :: Type -> Type)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule Op (,) (Product f g)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule Op (,) (Sum f g)

Defined in Data.Functor.Module

Bimodule Op (,) ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

(Functor f, Contravariant g) => Bimodule Op Either (Compose f g)

Defined in Data.Functor.Module

(Functor f, Contravariant g) => Bimodule Op Either (f :.: g)

Defined in Data.Functor.Module

Contravariant f => Bimodule Op Either (M1 i c f)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule Op (,) (Compose f g)

Defined in Data.Functor.Module

Bimodule (->) Either ZipList

Defined in Data.Functor.Module

Bimodule (->) Either Identity

Defined in Data.Functor.Module

Bimodule (->) Either IO

Defined in Data.Functor.Module

Bimodule (->) Either NonEmpty

Defined in Data.Functor.Module

Bimodule (->) Either Maybe

Defined in Data.Functor.Module

Bimodule (->) Either []

Defined in Data.Functor.Module

Bimodule (->) These ZipList

Defined in Data.Functor.Module

Bimodule (->) These Identity

Defined in Data.Functor.Module

Bimodule (->) These IO

Defined in Data.Functor.Module

Bimodule (->) These NonEmpty

Defined in Data.Functor.Module

Bimodule (->) These Maybe

Defined in Data.Functor.Module

Bimodule (->) These []

Defined in Data.Functor.Module

Bimodule (->) (,) Comparison

Defined in Data.Functor.Module

Bimodule (->) (,) Equivalence

Defined in Data.Functor.Module

Bimodule (->) (,) Predicate

Defined in Data.Functor.Module

Bimodule (->) Either (Either e)

Defined in Data.Functor.Module

Bimodule (->) Either (These a)

Defined in Data.Functor.Module

Bimodule (->) Either ((,) x1)

Defined in Data.Functor.Module

Bimodule (->) These (Either e)

Defined in Data.Functor.Module

Bimodule (->) These (These a)

Defined in Data.Functor.Module

Bimodule (->) These ((,) x1)

Defined in Data.Functor.Module

Bimodule (->) (,) (Op a)

Defined in Data.Functor.Module

Bimodule (->) (,) (Proxy :: Type -> Type)

Defined in Data.Functor.Module

Bimodule (->) (,) (U1 :: Type -> Type)

Defined in Data.Functor.Module

Bimodule (->) (,) (V1 :: Type -> Type)

Defined in Data.Functor.Module

Bimodule (->) Either ((,,) x1 x2)

Defined in Data.Functor.Module

Bimodule (->) These ((,,) x1 x2)

Defined in Data.Functor.Module

Bimodule (->) (,) (Const a :: Type -> Type)

Defined in Data.Functor.Module

Contravariant f => Bimodule (->) (,) (Alt f)

Defined in Data.Functor.Module

Contravariant f => Bimodule (->) (,) (Rec1 f)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule (->) Either (Product f g)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule (->) Either (Sum f g)

Defined in Data.Functor.Module

Bimodule (->) Either ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule (->) These (Product f g)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule (->) These (Sum f g)

Defined in Data.Functor.Module

Bimodule (->) These ((,,,) x1 x2 x3)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule (->) (,) (Product f g)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule (->) (,) (Sum f g)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule (->) (,) (f :*: g)

Defined in Data.Functor.Module

(Contravariant f, Contravariant g) => Bimodule (->) (,) (f :+: g)

Defined in Data.Functor.Module

Bimodule (->) (,) (K1 i c :: Type -> Type)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule (->) Either (Compose f g)

Defined in Data.Functor.Module

(Functor f, Functor g) => Bimodule (->) These (Compose f g)

Defined in Data.Functor.Module

(Functor f, Contravariant g) => Bimodule (->) (,) (Compose f g)

Defined in Data.Functor.Module

(Functor f, Contravariant g) => Bimodule (->) (,) (f :.: g)

Defined in Data.Functor.Module

Contravariant f => Bimodule (->) (,) (M1 i c f)

Defined in Data.Functor.Module