Data.Profunctor.Optic.Fold

Fold & Ixfold

type Fold s a = forall p. (Choice p, Representable p, Applicative (Rep p), forall x. Contravariant (p x)) => Optic' p s a

A Fold combines 0 or more elements, with Monoid interactions.

type Ixfold i s a = forall p. (Choice p, Representable p, Applicative (Rep p), forall x. Contravariant (p x)) => IndexedOptic' p i s a

fold_ :: Foldable f => (s -> f a) -> Fold s a

Obtain a Fold directly.

fold_ (lists o) ≡ o
fold_ f ≡ to f . foldVl traverse_
fold_ f ≡ coercer . lmap f . lift traverse_

See Property.

This can be useful to repn operations from Data.List and elsewhere into a Fold.

>>> [1,2,3,4] ^.. fold_ tail
[2,3,4]

folding :: Traversable f => (s -> a) -> Fold (f s) a

Obtain a Fold from a Traversable functor.

folding f ≡ traversed . to f
folding f ≡ foldVl traverse . to f

foldVl :: (forall f. Applicative f => (a -> f b) -> s -> f t) -> Fold s a

Obtain a Fold from a Van Laarhoven Fold.

toFold :: AView s a -> Fold s a

Obtain a Fold from a View or AFold.

cloneFold :: Monoid a => AFold a s a -> View s a

Obtain a Fold from a AFold.

Optics

folded :: Traversable f => Fold (f a) a

Obtain a Fold from a Traversable functor.

folded_ :: Foldable f => Fold (f a) a

The canonical Fold.

foldMap ≡ withFold folded_'

unital :: Foldable f => Foldable g => Monoid r => Semiring r => AFold r (f (g a)) a

Expression in a unital semiring

unital ≡ summed . multiplied

>>> folds unital [[1,2], [3,4 :: Int]]
14

For semirings without a multiplicative unit this is equivalent to const mempty:

>>> folds unital $ (fmap . fmap) Just [[1,2], [3,4 :: Int]]
Just 0

In this situation you most likely want to use nonunital.

summed :: Foldable f => Monoid r => AFold r (f a) a

Monoidal sum of a foldable collection.

>>> 1 <> 2 <> 3 <> 4 :: Int
10
>>> folds summed [1,2,3,4 :: Int]
10

summed and multiplied compose just as they do in arithmetic:

>>> 1 >< 2 <> 3 >< 4 :: Int
14
>>> folds (summed . multiplied) [[1,2], [3,4 :: Int]]
14
>>> (1 <> 2) >< (3 <> 4) :: Int
21
>>> folds (multiplied . summed) [[1,2], [3,4 :: Int]]
21

multiplied :: Foldable f => Monoid r => Semiring r => AFold r (f a) a

Semiring product of a foldable collection.

>>> 1 >< 2 >< 3 >< 4 :: Int
24
>>> folds multiplied [1,2,3,4 :: Int]
24

For semirings without a multiplicative unit this is equivalent to const mempty:

>>> folds multiplied $ fmap Just [1..(5 :: Int)]
Just 0

In this situation you most likely want to use multiplied1.

Primitive operators

withFold :: Monoid r => AFold r s a -> (a -> r) -> s -> r

Map an optic to a monoid and combine the results.

foldMap = withFold folded_'

>>> withFold both id (["foo"], ["bar", "baz"])
["foo","bar","baz"]

>>> :t withFold . fold_
withFold . fold_
  :: (Monoid r, Foldable f) => (s -> f a) -> (a -> r) -> s -> r

>>> :t withFold traversed
withFold traversed
  :: (Monoid r, Traversable f) => (a -> r) -> f a -> r

>>> :t withFold left
withFold left :: Monoid r => (a -> r) -> (a + c) -> r

>>> :t withFold t21
withFold t21 :: Monoid r => (a -> r) -> (a, b) -> r

>>> :t withFold $ selected even
withFold $ selected even
  :: (Monoid r, Integral a) => (b -> r) -> (a, b) -> r

>>> :t flip withFold Seq.singleton
flip withFold Seq.singleton :: AFold (Seq a) s a -> s -> Seq a

withIxfold :: AIxfold r i s a -> (i -> a -> r) -> i -> s -> r

TODO: Document

>>> :t flip withIxfold Map.singleton
flip withIxfold Map.singleton
  :: AIxfold (Map i a) i s a -> i -> s -> Map i a

Operators

(^..) :: s -> AFold (Endo [a]) s a -> [a] infixl 8

Infix version of lists.

toList xs ≡ xs ^.. folding
(^..) ≡ flip lists

>>> [[1,2], [3 :: Int]] ^.. id
[[[1,2],[3]]]
>>> [[1,2], [3 :: Int]] ^.. traversed
[[1,2],[3]]
>>> [[1,2], [3 :: Int]] ^.. traversed . traversed
[1,2,3]

>>> (1,2) ^.. bitraversed
[1,2]

(^..) :: s -> View s a     -> a :: s -> Fold s a       -> a :: s -> Lens' s a      -> a :: s -> Iso' s a       -> a :: s -> Traversal' s a -> a :: s -> Prism' s a     -> a :: s -> Affine' s a    -> [a]

(^??) :: Semigroup a => s -> AFold (Maybe a) s a -> Maybe a infixl 8

Return a semigroup aggregation of the foci, if they exist.

folds :: Monoid a => AFold a s a -> s -> a

TODO: Document

foldsa :: Applicative f => Monoid (f a) => AFold (f a) s a -> s -> f a

TODO: Document

foldsa :: Fold s a -> s -> [a]
foldsa :: Applicative f => Setter s t a b -> s -> f a

foldsp :: Monoid r => Semiring r => AFold (Prod r) s a -> (a -> r) -> s -> r

Compute the semiring product of the foci of an optic.

For semirings without a multiplicative unit this is equivalent to const mempty:

>>> foldsp folded Just [1..(5 :: Int)]
Just 0

In this situation you most likely want to use folds1p.

foldsr :: AFold (Endo r) s a -> (a -> r -> r) -> r -> s -> r

Right fold over an optic.

>>> foldsr folded (<>) 0 [1..5::Int]
15

foldsl :: AFold (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r

Left fold over an optic.

foldsl' :: AFold (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r

Fold repn the elements of a structure, associating to the left, but strictly.

foldl' ≡ foldsl' folding

foldsl' :: Iso' s a        -> (c -> a -> c) -> c -> s -> c
foldsl' :: Lens' s a       -> (c -> a -> c) -> c -> s -> c
foldsl' :: View s a        -> (c -> a -> c) -> c -> s -> c
foldsl' :: Fold s a        -> (c -> a -> c) -> c -> s -> c
foldsl' :: Traversal' s a  -> (c -> a -> c) -> c -> s -> c
foldsl' :: Traversal0' s a -> (c -> a -> c) -> c -> s -> c

lists :: AFold (Endo [a]) s a -> s -> [a]

Collect the foci of an optic into a list.

traverses_ :: Applicative f => AFold (Endo (f ())) s a -> (a -> f r) -> s -> f ()

Collect an applicative over the foci of an optic.

>>> traverses_ both putStrLn ("hello","world")
hello
world

traverse_ ≡ traverses_ folded

concats :: AFold [r] s a -> (a -> [r]) -> s -> [r]

Map a function over all the foci of an optic and concatenate the resulting lists.

>>> concats both (\x -> [x, x + 1]) (1,3)
[1,2,3,4]

concatMap ≡ concats folded

finds :: AFold (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a

Find the first focus of an optic that satisfies a predicate, if one exists.

>>> finds both even (1,4)
Just 4

>>> finds folded even [1,3,5,7]
Nothing

find ≡ finds folded

has :: AFold Any s a -> s -> Bool

Determine whether an optic has at least one focus.

hasnt :: AFold All s a -> s -> Bool

Determine whether an optic does not have a focus.

nulls :: AFold All s a -> s -> Bool

TODO: Document

asums :: Alternative f => AFold (Endo (Endo (f a))) s (f a) -> s -> f a

The sum of a collection of actions, generalizing concatOf.

>>> asums both ("hello","world")
"helloworld"

>>> asums both (Nothing, Just "hello")
Just "hello"

asum ≡ asums folded

joins :: Lattice a => AFold (Endo (Endo a)) s a -> a -> s -> a

Compute the join of the foci of an optic.

joins' :: Lattice a => Min a => AFold (Endo (Endo a)) s a -> s -> a

Compute the join of the foci of an optic including a least element.

meets :: Lattice a => AFold (Endo (Endo a)) s a -> a -> s -> a

Compute the meet of the foci of an optic .

meets' :: Lattice a => Max a => AFold (Endo (Endo a)) s a -> s -> a

Compute the meet of the foci of an optic including a greatest element.

pelem :: Prd a => AFold Any s a -> a -> s -> Bool

Determine whether the foci of an optic contain an element equivalent to a given element.

Indexed operators

(^%%) :: Monoid i => s -> AIxfold (Endo [(i, a)]) i s a -> [(i, a)] infixl 8

Infix version of ixlists.

ixfoldsr :: Monoid i => AIxfold (Endo r) i s a -> (i -> a -> r -> r) -> r -> s -> r

Indexed right fold over an indexed optic.

foldsr o ≡ ixfoldsr o . const

>>> ixfoldsr ixtraversed (\i a -> ((show i ++ ":" ++ show a ++ ", ") ++)) [] [1,3,5,7,9]
"0:1, 1:3, 2:5, 3:7, 4:9, "

ixfoldsrFrom :: AIxfold (Endo r) i s a -> (i -> a -> r -> r) -> i -> r -> s -> r

Indexed right fold over an indexed optic, using an initial index value.

ixfoldsl :: Monoid i => AIxfold (Dual (Endo r)) i s a -> (i -> r -> a -> r) -> r -> s -> r

Indexed left fold over an indexed optic.

foldsl ≡ ixfoldsl . const

ixfoldslFrom :: AIxfold (Dual (Endo r)) i s a -> (i -> r -> a -> r) -> i -> r -> s -> r

Indexed left fold over an indexed optic, using an initial index value.

ixfoldsrM :: Monoid i => Monad m => AIxfold (Dual (Endo (r -> m r))) i s a -> (i -> a -> r -> m r) -> r -> s -> m r

Indexed monadic right fold over an indexed optic.

foldsrM ≡ ixfoldrM . const

ixfoldsrMFrom :: Monad m => AIxfold (Dual (Endo (r -> m r))) i s a -> (i -> a -> r -> m r) -> i -> r -> s -> m r

Indexed monadic right fold over an Ixfold, using an initial index value.

ixfoldslM :: Monoid i => Monad m => AIxfold (Endo (r -> m r)) i s a -> (i -> r -> a -> m r) -> r -> s -> m r

Indexed monadic left fold over an indexed optic.

foldslM ≡ ixfoldslM . const

ixfoldslMFrom :: Monad m => AIxfold (Endo (r -> m r)) i s a -> (i -> r -> a -> m r) -> i -> r -> s -> m r

Indexed monadic left fold over an indexed optic, using an initial index value.

ixlists :: Monoid i => AIxfold (Endo [(i, a)]) i s a -> s -> [(i, a)]

Extract the key-value pairs from the foci of an indexed optic.

lists l ≡ map snd . ixlists l

ixlistsFrom :: AIxfold (Endo [(i, a)]) i s a -> i -> s -> [(i, a)]

Extract key-value pairs from the foci of an indexed optic, using an initial index value.

ixtraverses_ :: Monoid i => Applicative f => AIxfold (Endo (f ())) i s a -> (i -> a -> f r) -> s -> f ()

Collect an applicative over the foci of an indexed optic.

ixconcats :: Monoid i => AIxfold [r] i s a -> (i -> a -> [r]) -> s -> [r]

Concatenate the results of a function of the foci of an indexed optic.

concats o ≡ ixconcats o . const

>>> ixconcats ixtraversed (\i x -> [i + x, i + x + 1]) [1,2,3,4]
[1,2,3,4,5,6,7,8]

ixfinds :: Monoid i => AIxfold (Endo (Maybe (i, a))) i s a -> (i -> a -> Bool) -> s -> Maybe (i, a)

Find the first focus of an indexed optic that satisfies a predicate, if one exists.

Auxilliary Types

type All = Prod Bool

type Any = Bool

Carriers

type FoldRep r = Star (Const r)

type AFold r s a = Optic' (FoldRep r) s a

type AIxfold r i s a = IndexedOptic' (FoldRep r) i s a

afold :: ((a -> r) -> s -> r) -> AFold r s a

TODO: Document

newtype Star (f :: Type -> Type) d c

Lift a Functor into a Profunctor (forwards).

Constructors

Star

Fields

• runStar :: d -> f c

Instances

Functor f => Representable (Star f)

Defined in Data.Profunctor.Rep

Associated Types

type Rep (Star f) :: Type -> Type

Methods

tabulate :: (d -> Rep (Star f) c) -> Star f d c

Applicative f => Choice (Star f)

Defined in Data.Profunctor.Choice

Methods

left' :: Star f a b -> Star f (Either a c) (Either b c)

right' :: Star f a b -> Star f (Either c a) (Either c b)

Traversable f => Cochoice (Star f)

Defined in Data.Profunctor.Choice

Methods

unleft :: Star f (Either a d) (Either b d) -> Star f a b

unright :: Star f (Either d a) (Either d b) -> Star f a b

Distributive f => Closed (Star f)

Defined in Data.Profunctor.Closed

Methods

closed :: Star f a b -> Star f (x -> a) (x -> b)

Functor m => Strong (Star m)

Defined in Data.Profunctor.Strong

Methods

first' :: Star m a b -> Star m (a, c) (b, c)

second' :: Star m a b -> Star m (c, a) (c, b)

Functor f => Profunctor (Star f)

Defined in Data.Profunctor.Types

Methods

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

lmap :: (a -> b) -> Star f b c -> Star f a c

rmap :: (b -> c) -> Star f a b -> Star f a c

(#.) :: Coercible c b => q b c -> Star f a b -> Star f a c

(.#) :: Coercible b a => Star f b c -> q a b -> Star f a c

Functor f => Sieve (Star f) f

Defined in Data.Profunctor.Sieve

Methods

sieve :: Star f a b -> a -> f b

Monad f => Category (Star f :: Type -> Type -> Type)

Defined in Data.Profunctor.Types

Methods

id :: Star f a a

(.) :: Star f b c -> Star f a b -> Star f a c

Monad f => Monad (Star f a)

Defined in Data.Profunctor.Types

Methods

(>>=) :: Star f a a0 -> (a0 -> Star f a b) -> Star f a b

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

return :: a0 -> Star f a a0

fail :: String -> Star f a a0

Functor f => Functor (Star f a)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Star f a a0 -> Star f a b

(<$) :: a0 -> Star f a b -> Star f a a0

Applicative f => Applicative (Star f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Star f a a0

(<*>) :: Star f a (a0 -> b) -> Star f a a0 -> Star f a b

liftA2 :: (a0 -> b -> c) -> Star f a a0 -> Star f a b -> Star f a c

(*>) :: Star f a a0 -> Star f a b -> Star f a b

(<*) :: Star f a a0 -> Star f a b -> Star f a a0

Contravariant f => Contravariant (Star f a)

Defined in Data.Profunctor.Optic.Type

Methods

contramap :: (a0 -> b) -> Star f a b -> Star f a a0

(>$) :: b -> Star f a b -> Star f a a0

Alternative f => Alternative (Star f a)

Defined in Data.Profunctor.Types

Methods

empty :: Star f a a0

(<|>) :: Star f a a0 -> Star f a a0 -> Star f a a0

some :: Star f a a0 -> Star f a [a0]

many :: Star f a a0 -> Star f a [a0]

MonadPlus f => MonadPlus (Star f a)

Defined in Data.Profunctor.Types

Methods

mzero :: Star f a a0

mplus :: Star f a a0 -> Star f a a0 -> Star f a a0

Distributive f => Distributive (Star f a)

Defined in Data.Profunctor.Types

Methods

distribute :: Functor f0 => f0 (Star f a a0) -> Star f a (f0 a0)

collect :: Functor f0 => (a0 -> Star f a b) -> f0 a0 -> Star f a (f0 b)

distributeM :: Monad m => m (Star f a a0) -> Star f a (m a0)

collectM :: Monad m => (a0 -> Star f a b) -> m a0 -> Star f a (m b)

Apply f => Apply (Star f a)

Defined in Data.Profunctor.Optic.Type

Methods

(<.>) :: Star f a (a0 -> b) -> Star f a a0 -> Star f a b

(.>) :: Star f a a0 -> Star f a b -> Star f a b

(<.) :: Star f a a0 -> Star f a b -> Star f a a0

liftF2 :: (a0 -> b -> c) -> Star f a a0 -> Star f a b -> Star f a c

type Rep (Star f)

Defined in Data.Profunctor.Rep

type Rep (Star f) = f

newtype Costar (f :: Type -> Type) d c

Lift a Functor into a Profunctor (backwards).

Constructors

Costar

Fields

• runCostar :: f d -> c

Instances

Contravariant f => Bifunctor (Costar f)

Defined in Data.Profunctor.Optic.Type

Methods

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

first :: (a -> b) -> Costar f a c -> Costar f b c

second :: (b -> c) -> Costar f a b -> Costar f a c

Functor f => Corepresentable (Costar f)

Defined in Data.Profunctor.Rep

Associated Types

type Corep (Costar f) :: Type -> Type

Methods

cotabulate :: (Corep (Costar f) d -> c) -> Costar f d c

Traversable w => Choice (Costar w)

Defined in Data.Profunctor.Choice

Methods

left' :: Costar w a b -> Costar w (Either a c) (Either b c)

right' :: Costar w a b -> Costar w (Either c a) (Either c b)

Applicative f => Cochoice (Costar f)

Defined in Data.Profunctor.Choice

Methods

unleft :: Costar f (Either a d) (Either b d) -> Costar f a b

unright :: Costar f (Either d a) (Either d b) -> Costar f a b

Functor f => Closed (Costar f)

Defined in Data.Profunctor.Closed

Methods

closed :: Costar f a b -> Costar f (x -> a) (x -> b)

Comonad f => Strong (Costar f)

Defined in Data.Profunctor.Optic.Type

Methods

first' :: Costar f a b -> Costar f (a, c) (b, c)

second' :: Costar f a b -> Costar f (c, a) (c, b)

Functor f => Costrong (Costar f)

Defined in Data.Profunctor.Strong

Methods

unfirst :: Costar f (a, d) (b, d) -> Costar f a b

unsecond :: Costar f (d, a) (d, b) -> Costar f a b

Functor f => Profunctor (Costar f)

Defined in Data.Profunctor.Types

Methods

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

lmap :: (a -> b) -> Costar f b c -> Costar f a c

rmap :: (b -> c) -> Costar f a b -> Costar f a c

(#.) :: Coercible c b => q b c -> Costar f a b -> Costar f a c

(.#) :: Coercible b a => Costar f b c -> q a b -> Costar f a c

Functor f => Cosieve (Costar f) f

Defined in Data.Profunctor.Sieve

Methods

cosieve :: Costar f a b -> f a -> b

Monad (Costar f a)

Defined in Data.Profunctor.Types

Methods

(>>=) :: Costar f a a0 -> (a0 -> Costar f a b) -> Costar f a b

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

return :: a0 -> Costar f a a0

fail :: String -> Costar f a a0

Functor (Costar f a)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Costar f a a0 -> Costar f a b

(<$) :: a0 -> Costar f a b -> Costar f a a0

Applicative (Costar f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Costar f a a0

(<*>) :: Costar f a (a0 -> b) -> Costar f a a0 -> Costar f a b

liftA2 :: (a0 -> b -> c) -> Costar f a a0 -> Costar f a b -> Costar f a c

(*>) :: Costar f a a0 -> Costar f a b -> Costar f a b

(<*) :: Costar f a a0 -> Costar f a b -> Costar f a a0

Distributive (Costar f d)

Defined in Data.Profunctor.Types

Methods

distribute :: Functor f0 => f0 (Costar f d a) -> Costar f d (f0 a)

collect :: Functor f0 => (a -> Costar f d b) -> f0 a -> Costar f d (f0 b)

distributeM :: Monad m => m (Costar f d a) -> Costar f d (m a)

collectM :: Monad m => (a -> Costar f d b) -> m a -> Costar f d (m b)

type Corep (Costar f)

Defined in Data.Profunctor.Rep

type Corep (Costar f) = f

Classes

class (Sieve p (Rep p), Strong p) => Representable (p :: Type -> Type -> Type) where

A Profunctor p is Representable if there exists a Functor f such that p d c is isomorphic to d -> f c.

Associated Types

type Rep (p :: Type -> Type -> Type) :: Type -> Type

Methods

tabulate :: (d -> Rep p c) -> p d c

Laws:

tabulate . sieve ≡ id
sieve . tabulate ≡ id

Instances

(Monad m, Functor m) => Representable (Kleisli m)

Defined in Data.Profunctor.Rep

Associated Types

type Rep (Kleisli m) :: Type -> Type

Methods

tabulate :: (d -> Rep (Kleisli m) c) -> Kleisli m d c

Functor f => Representable (Star f)

Defined in Data.Profunctor.Rep

Associated Types

type Rep (Star f) :: Type -> Type

Methods

tabulate :: (d -> Rep (Star f) c) -> Star f d c

Representable (Forget r)

Defined in Data.Profunctor.Rep

Associated Types

type Rep (Forget r) :: Type -> Type

Methods

tabulate :: (d -> Rep (Forget r) c) -> Forget r d c

Representable (Fold0Rep r)

Defined in Data.Profunctor.Optic.Fold0

Associated Types

type Rep (Fold0Rep r) :: Type -> Type

Methods

tabulate :: (d -> Rep (Fold0Rep r) c) -> Fold0Rep r d c

Representable ((->) :: Type -> Type -> Type)

Defined in Data.Profunctor.Rep

Associated Types

type Rep (->) :: Type -> Type

Methods

tabulate :: (d -> Rep (->) c) -> d -> c

Representable (LensRep a b)

Defined in Data.Profunctor.Optic.Lens

Associated Types

type Rep (LensRep a b) :: Type -> Type

Methods

tabulate :: (d -> Rep (LensRep a b) c) -> LensRep a b d c

Representable (Traversal0Rep a b)

Defined in Data.Profunctor.Optic.Traversal0

Associated Types

type Rep (Traversal0Rep a b) :: Type -> Type

Methods

tabulate :: (d -> Rep (Traversal0Rep a b) c) -> Traversal0Rep a b d c

class (Cosieve p (Corep p), Costrong p) => Corepresentable (p :: Type -> Type -> Type) where

A Profunctor p is Corepresentable if there exists a Functor f such that p d c is isomorphic to f d -> c.

Associated Types

type Corep (p :: Type -> Type -> Type) :: Type -> Type

Methods

cotabulate :: (Corep p d -> c) -> p d c

Laws:

cotabulate . cosieve ≡ id
cosieve . cotabulate ≡ id

Instances

Functor f => Corepresentable (Costar f)

Defined in Data.Profunctor.Rep

Associated Types

type Corep (Costar f) :: Type -> Type

Methods

cotabulate :: (Corep (Costar f) d -> c) -> Costar f d c

Corepresentable (Tagged :: Type -> Type -> Type)

Defined in Data.Profunctor.Rep

Associated Types

type Corep Tagged :: Type -> Type

Methods

cotabulate :: (Corep Tagged d -> c) -> Tagged d c

Corepresentable ((->) :: Type -> Type -> Type)

Defined in Data.Profunctor.Rep

Associated Types

type Corep (->) :: Type -> Type

Methods

cotabulate :: (Corep (->) d -> c) -> d -> c

Functor w => Corepresentable (Cokleisli w)

Defined in Data.Profunctor.Rep

Associated Types

type Corep (Cokleisli w) :: Type -> Type

Methods

cotabulate :: (Corep (Cokleisli w) d -> c) -> Cokleisli w d c

Corepresentable (GrateRep a b)

Defined in Data.Profunctor.Optic.Grate

Associated Types

type Corep (GrateRep a b) :: Type -> Type

Methods

cotabulate :: (Corep (GrateRep a b) d -> c) -> GrateRep a b d c

class Contravariant (f :: Type -> Type) where

The class of contravariant functors.

Whereas in Haskell, one can think of a Functor as containing or producing values, a contravariant functor is a functor that can be thought of as consuming values.

As an example, consider the type of predicate functions a -> Bool. One such predicate might be negative x = x < 0, which classifies integers as to whether they are negative. However, given this predicate, we can re-use it in other situations, providing we have a way to map values to integers. For instance, we can use the negative predicate on a person's bank balance to work out if they are currently overdrawn:

newtype Predicate a = Predicate { getPredicate :: a -> Bool }

instance Contravariant Predicate where
  contramap f (Predicate p) = Predicate (p . f)
                                         |   `- First, map the input...
                                         `----- then apply the predicate.

overdrawn :: Predicate Person
overdrawn = contramap personBankBalance negative

Any instance should be subject to the following laws:

contramap id = id
contramap f . contramap g = contramap (g . f)

Note, that the second law follows from the free theorem of the type of contramap and the first law, so you need only check that the former condition holds.

Minimal complete definition

contramap

Methods

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

(>$) :: b -> f b -> f a infixl 4

Replace all locations in the output with the same value. The default definition is contramap . const, but this may be overridden with a more efficient version.

Instances

Contravariant Predicate

A Predicate is a Contravariant Functor, because contramap can apply its function argument to the input of the predicate.

Defined in Data.Functor.Contravariant

Methods

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

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

Contravariant Comparison

A Comparison is a Contravariant Functor, because contramap can apply its function argument to each input of the comparison function.

Defined in Data.Functor.Contravariant

Methods

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

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

Contravariant Equivalence

Equivalence relations are Contravariant, because you can apply the contramapped function to each input to the equivalence relation.

Defined in Data.Functor.Contravariant

Methods

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

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

Contravariant (V1 :: Type -> Type)

Defined in Data.Functor.Contravariant

Methods

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

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

Contravariant (U1 :: Type -> Type)

Defined in Data.Functor.Contravariant

Methods

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

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

Contravariant (Op a)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a0 -> b) -> Op a b -> Op a a0

(>$) :: b -> Op a b -> Op a a0

Contravariant (Proxy :: Type -> Type)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> Proxy b -> Proxy a

(>$) :: b -> Proxy b -> Proxy a

Contravariant m => Contravariant (ListT m)

Defined in Control.Monad.Trans.List

Methods

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

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

Contravariant m => Contravariant (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

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

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

Contravariant (Pre a)

Defined in Data.Profunctor.Optic.Fold0

Methods

contramap :: (a0 -> b) -> Pre a b -> Pre a a0

(>$) :: b -> Pre a b -> Pre a a0

Contravariant f => Contravariant (Rec1 f)

Defined in Data.Functor.Contravariant

Methods

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

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

Contravariant (Const a :: Type -> Type)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a0 -> b) -> Const a b -> Const a a0

(>$) :: b -> Const a b -> Const a a0

Contravariant f => Contravariant (Alt f)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> Alt f b -> Alt f a

(>$) :: b -> Alt f b -> Alt f a

Contravariant f => Contravariant (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

contramap :: (a -> b) -> IdentityT f b -> IdentityT f a

(>$) :: b -> IdentityT f b -> IdentityT f a

Contravariant m => Contravariant (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

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

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

Contravariant m => Contravariant (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

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

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

Contravariant m => Contravariant (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

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

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

Contravariant m => Contravariant (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

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

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

Contravariant m => Contravariant (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

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

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

Contravariant m => Contravariant (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

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

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

Contravariant f => Contravariant (Star f a)

Defined in Data.Profunctor.Optic.Type

Methods

contramap :: (a0 -> b) -> Star f a b -> Star f a a0

(>$) :: b -> Star f a b -> Star f a a0

Contravariant f => Contravariant (Reverse f)

Derived instance.

Defined in Data.Functor.Reverse

Methods

contramap :: (a -> b) -> Reverse f b -> Reverse f a

(>$) :: b -> Reverse f b -> Reverse f a

Contravariant (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

contramap :: (a0 -> b) -> Constant a b -> Constant a a0

(>$) :: b -> Constant a b -> Constant a a0

Contravariant f => Contravariant (Backwards f)

Derived instance.

Defined in Control.Applicative.Backwards

Methods

contramap :: (a -> b) -> Backwards f b -> Backwards f a

(>$) :: b -> Backwards f b -> Backwards f a

Contravariant (Fold0Rep r a)

Defined in Data.Profunctor.Optic.Fold0

Methods

contramap :: (a0 -> b) -> Fold0Rep r a b -> Fold0Rep r a a0

(>$) :: b -> Fold0Rep r a b -> Fold0Rep r a a0

Contravariant (K1 i c :: Type -> Type)

Defined in Data.Functor.Contravariant

Methods

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

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

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

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> (f :+: g) b -> (f :+: g) a

(>$) :: b -> (f :+: g) b -> (f :+: g) a

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

Defined in Data.Functor.Contravariant

Methods

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

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

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

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> Product f g b -> Product f g a

(>$) :: b -> Product f g b -> Product f g a

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

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> Sum f g b -> Sum f g a

(>$) :: b -> Sum f g b -> Sum f g a

Contravariant m => Contravariant (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

contramap :: (a -> b) -> ReaderT r m b -> ReaderT r m a

(>$) :: b -> ReaderT r m b -> ReaderT r m a

Contravariant f => Contravariant (M1 i c f)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> M1 i c f b -> M1 i c f a

(>$) :: b -> M1 i c f b -> M1 i c f a

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

Defined in Data.Functor.Contravariant

Methods

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

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

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

Defined in Data.Functor.Contravariant

Methods

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

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

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

Defined in Control.Monad.Trans.RWS.Lazy

Methods

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

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

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

Defined in Control.Monad.Trans.RWS.Strict

Methods

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

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

Bifunctor p => Contravariant (Re p s t a)

Defined in Data.Profunctor.Optic.Type

Methods

contramap :: (a0 -> b) -> Re p s t a b -> Re p s t a a0

(>$) :: b -> Re p s t a b -> Re p s t a a0

class Bifunctor (p :: Type -> Type -> Type) where

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor, a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second.

If you supply bimap, you should ensure that:

bimap id id ≡ id

If you supply first and second, ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: base-4.8.0.0

Minimal complete definition

bimap | first, second

Methods

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

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

>>> bimap toUpper (+1) ('j', 3)
('J',4)

>>> bimap toUpper (+1) (Left 'j')
Left 'J'

>>> bimap toUpper (+1) (Right 3)
Right 4

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

Map covariantly over the first argument.

first f ≡ bimap f id

Examples

>>> first toUpper ('j', 3)
('J',3)

>>> first toUpper (Left 'j')
Left 'J'

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

Map covariantly over the second argument.

second ≡ bimap id

Examples

>>> second (+1) ('j', 3)
('j',4)

>>> second (+1) (Right 3)
Right 4

Instances

Bifunctor Either

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

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

first :: (a -> b) -> Either a c -> Either b c

second :: (b -> c) -> Either a b -> Either a c

Bifunctor (,)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

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

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

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

Bifunctor Arg

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

first :: (a -> b) -> Arg a c -> Arg b c

second :: (b -> c) -> Arg a b -> Arg a c

Bifunctor ((,,) x1)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d)

first :: (a -> b) -> (x1, a, c) -> (x1, b, c)

second :: (b -> c) -> (x1, a, b) -> (x1, a, c)

Bifunctor (Const :: Type -> Type -> Type)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d

first :: (a -> b) -> Const a c -> Const b c

second :: (b -> c) -> Const a b -> Const a c

Contravariant f => Bifunctor (Costar f)

Defined in Data.Profunctor.Optic.Type

Methods

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

first :: (a -> b) -> Costar f a c -> Costar f b c

second :: (b -> c) -> Costar f a b -> Costar f a c

Bifunctor (Tagged :: Type -> Type -> Type)

Defined in Data.Tagged

Methods

bimap :: (a -> b) -> (c -> d) -> Tagged a c -> Tagged b d

first :: (a -> b) -> Tagged a c -> Tagged b c

second :: (b -> c) -> Tagged a b -> Tagged a c

Bifunctor (Constant :: Type -> Type -> Type)

Defined in Data.Functor.Constant

Methods

bimap :: (a -> b) -> (c -> d) -> Constant a c -> Constant b d

first :: (a -> b) -> Constant a c -> Constant b c

second :: (b -> c) -> Constant a b -> Constant a c

Bifunctor (K1 i :: Type -> Type -> Type)

Since: base-4.9.0.0

Defined in Data.Bifunctor

Methods

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

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

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

Bifunctor ((,,,) x1 x2)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d)

first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c)

second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c)

Bifunctor ((,,,,) x1 x2 x3)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d)

first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c)

second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c)

Bifunctor p => Bifunctor (WrappedBifunctor p)

Defined in Data.Bifunctor.Wrapped

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

Functor g => Bifunctor (Joker g :: Type -> Type -> Type)

Defined in Data.Bifunctor.Joker

Methods

bimap :: (a -> b) -> (c -> d) -> Joker g a c -> Joker g b d

first :: (a -> b) -> Joker g a c -> Joker g b c

second :: (b -> c) -> Joker g a b -> Joker g a c

Bifunctor p => Bifunctor (Flip p)

Defined in Data.Bifunctor.Flip

Methods

bimap :: (a -> b) -> (c -> d) -> Flip p a c -> Flip p b d

first :: (a -> b) -> Flip p a c -> Flip p b c

second :: (b -> c) -> Flip p a b -> Flip p a c

Functor f => Bifunctor (Clown f :: Type -> Type -> Type)

Defined in Data.Bifunctor.Clown

Methods

bimap :: (a -> b) -> (c -> d) -> Clown f a c -> Clown f b d

first :: (a -> b) -> Clown f a c -> Clown f b c

second :: (b -> c) -> Clown f a b -> Clown f a c

(Profunctor p, forall x. Contravariant (p x)) => Bifunctor (Re p s t)

Defined in Data.Profunctor.Optic.Type

Methods

bimap :: (a -> b) -> (c -> d) -> Re p s t a c -> Re p s t b d

first :: (a -> b) -> Re p s t a c -> Re p s t b c

second :: (b -> c) -> Re p s t a b -> Re p s t a c

Bifunctor ((,,,,,) x1 x2 x3 x4)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d)

first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c)

second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c)

(Bifunctor p, Bifunctor q) => Bifunctor (Sum p q)

Defined in Data.Bifunctor.Sum

Methods

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

first :: (a -> b) -> Sum p q a c -> Sum p q b c

second :: (b -> c) -> Sum p q a b -> Sum p q a c

(Bifunctor f, Bifunctor g) => Bifunctor (Product f g)

Defined in Data.Bifunctor.Product

Methods

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

first :: (a -> b) -> Product f g a c -> Product f g b c

second :: (b -> c) -> Product f g a b -> Product f g a c

Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d)

first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c)

second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c)

(Functor f, Bifunctor p) => Bifunctor (Tannen f p)

Defined in Data.Bifunctor.Tannen

Methods

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

first :: (a -> b) -> Tannen f p a c -> Tannen f p b c

second :: (b -> c) -> Tannen f p a b -> Tannen f p a c

(Bifunctor p, Functor f, Functor g) => Bifunctor (Biff p f g)

Defined in Data.Bifunctor.Biff

Methods

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

first :: (a -> b) -> Biff p f g a c -> Biff p f g b c

second :: (b -> c) -> Biff p f g a b -> Biff p f g a c