Copyright	(C) 2013-16 Edward Kmett
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	experimental
Portability	non-portable
Safe Haskell	Safe-Inferred
Language	Haskell2010

Control.Lens.Combinators

Description

This lets the subset of users who vociferously disagree about the full scope and set of operators that should be exported from lens to not have to look at any operator with which they disagree.

import Control.Lens.Combinators

Synopsis

class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
class Bifunctor (p :: Type -> Type -> Type) where
- bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
class Contravariant (f :: Type -> Type) where
- contramap :: (a' -> a) -> f a -> f a'
- (>$) :: b -> f b -> f a
newtype Identity a = Identity {
- runIdentity :: a
}
newtype Const a (b :: k) = Const {
- getConst :: a
}
data (a :: k) :~: (b :: k) where
- Refl :: forall {k} (a :: k). a :~: a
itoList :: FoldableWithIndex i f => f a -> [(i, a)]
ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b
ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b
ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a)
iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b]
iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m ()
imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()
ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f ()
itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f ()
none :: Foldable f => (a -> Bool) -> f a -> Bool
inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b)
imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)
ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b)
class Functor f => FunctorWithIndex i (f :: Type -> Type) | f -> i where
- imap :: (i -> a -> b) -> f a -> f b
class Foldable f => FoldableWithIndex i (f :: Type -> Type) | f -> i where
- ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m
- ifoldMap' :: Monoid m => (i -> a -> m) -> f a -> m
- ifoldr :: (i -> a -> b -> b) -> b -> f a -> b
- ifoldl :: (i -> b -> a -> b) -> b -> f a -> b
- ifoldr' :: (i -> a -> b -> b) -> b -> f a -> b
- ifoldl' :: (i -> b -> a -> b) -> b -> f a -> b
class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: Type -> Type) | t -> i where
- itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b)
class Profunctor p => Choice (p :: Type -> Type -> Type) where
- left' :: p a b -> p (Either a c) (Either b c)
- right' :: p a b -> p (Either c a) (Either c b)
class Profunctor (p :: Type -> Type -> Type) where
- dimap :: (a -> b) -> (c -> d) -> p b c -> p a d
- lmap :: (a -> b) -> p b c -> p a c
- rmap :: (b -> c) -> p a b -> p a c
sequenceBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> t (f a) -> f (t a)
traverseBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b)
foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r
foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a
class (Foldable1 t, Traversable t) => Traversable1 (t :: Type -> Type) where
- traverse1 :: Apply f => (a -> f b) -> t a -> f (t b)
class Reversing t where
- reversing :: t -> t
data Level i a
newtype Indexed i a b = Indexed {
- runIndexed :: i -> a -> b
}
class Conjoined p => Indexable i p where
- indexed :: p a b -> i -> a -> b
class (Choice p, Corepresentable p, Comonad (Corep p), Traversable (Corep p), Strong p, Representable p, Monad (Rep p), MonadFix (Rep p), Distributive (Rep p), Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined p where
- distrib :: Functor f => p a b -> p (f a) (f b)
- conjoined :: (p ~ (->) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t
withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)
asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)
data Rightmost a
data Leftmost a
data Sequenced a m
data Traversed a f
type Context' a = Context a a
data Context a b t = Context (b -> t) a
type Bazaar1' p a = Bazaar1 p a a
newtype Bazaar1 p a b t = Bazaar1 {
- runBazaar1 :: forall f. Apply f => p a (f b) -> f t
}
type Bazaar' p a = Bazaar p a a
newtype Bazaar p a b t = Bazaar {
- runBazaar :: forall f. Applicative f => p a (f b) -> f t
}
data Magma i t b a
class (Profunctor p, Bifunctor p) => Reviewable p
retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b
class (Applicative f, Distributive f, Traversable f) => Settable f
type Over' p f s a = Over p f s s a a
type Over p f s t a b = p a (f b) -> s -> f t
type IndexedLensLike' i f s a = IndexedLensLike i f s s a a
type IndexedLensLike i f s t a b = forall p. Indexable i p => p a (f b) -> s -> f t
type LensLike' f s a = LensLike f s s a a
type LensLike f s t a b = (a -> f b) -> s -> f t
type Optical' p q f s a = Optical p q f s s a a
type Optical p q f s t a b = p a (f b) -> q s (f t)
type Optic' p f s a = Optic p f s s a a
type Optic p f s t a b = p a (f b) -> p s (f t)
type Simple f s a = f s s a a
type IndexPreservingFold1 s a = forall p f. (Conjoined p, Contravariant f, Apply f) => p a (f a) -> p s (f s)
type IndexedFold1 i s a = forall p f. (Indexable i p, Contravariant f, Apply f) => p a (f a) -> s -> f s
type Fold1 s a = forall f. (Contravariant f, Apply f) => (a -> f a) -> s -> f s
type IndexPreservingFold s a = forall p f. (Conjoined p, Contravariant f, Applicative f) => p a (f a) -> p s (f s)
type IndexedFold i s a = forall p f. (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> s -> f s
type Fold s a = forall f. (Contravariant f, Applicative f) => (a -> f a) -> s -> f s
type IndexPreservingGetter s a = forall p f. (Conjoined p, Contravariant f, Functor f) => p a (f a) -> p s (f s)
type IndexedGetter i s a = forall p f. (Indexable i p, Contravariant f, Functor f) => p a (f a) -> s -> f s
type Getter s a = forall f. (Contravariant f, Functor f) => (a -> f a) -> s -> f s
type As a = Equality' a a
type Equality' s a = Equality s s a a
type Equality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = forall k3 (p :: k1 -> k3 -> Type) (f :: k2 -> k3). p a (f b) -> p s (f t)
type Prism' s a = Prism s s a a
type Prism s t a b = forall p f. (Choice p, Applicative f) => p a (f b) -> p s (f t)
type AReview t b = Optic' Tagged Identity t b
type Review t b = forall p f. (Choice p, Bifunctor p, Settable f) => Optic' p f t b
type Iso' s a = Iso s s a a
type Iso s t a b = forall p f. (Profunctor p, Functor f) => p a (f b) -> p s (f t)
type IndexPreservingSetter' s a = IndexPreservingSetter s s a a
type IndexPreservingSetter s t a b = forall p f. (Conjoined p, Settable f) => p a (f b) -> p s (f t)
type IndexedSetter' i s a = IndexedSetter i s s a a
type IndexedSetter i s t a b = forall f p. (Indexable i p, Settable f) => p a (f b) -> s -> f t
type Setter' s a = Setter s s a a
type Setter s t a b = forall f. Settable f => (a -> f b) -> s -> f t
type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a
type IndexPreservingTraversal1 s t a b = forall p f. (Conjoined p, Apply f) => p a (f b) -> p s (f t)
type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a
type IndexPreservingTraversal s t a b = forall p f. (Conjoined p, Applicative f) => p a (f b) -> p s (f t)
type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a
type IndexedTraversal1 i s t a b = forall p f. (Indexable i p, Apply f) => p a (f b) -> s -> f t
type IndexedTraversal' i s a = IndexedTraversal i s s a a
type IndexedTraversal i s t a b = forall p f. (Indexable i p, Applicative f) => p a (f b) -> s -> f t
type Traversal1' s a = Traversal1 s s a a
type Traversal1 s t a b = forall f. Apply f => (a -> f b) -> s -> f t
type Traversal' s a = Traversal s s a a
type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t
type IndexPreservingLens' s a = IndexPreservingLens s s a a
type IndexPreservingLens s t a b = forall p f. (Conjoined p, Functor f) => p a (f b) -> p s (f t)
type IndexedLens' i s a = IndexedLens i s s a a
type IndexedLens i s t a b = forall f p. (Indexable i p, Functor f) => p a (f b) -> s -> f t
type Lens' s a = Lens s s a a
type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t
type Setting' p s a = Setting p s s a a
type Setting p s t a b = p a (Identity b) -> s -> Identity t
type AnIndexedSetter' i s a = AnIndexedSetter i s s a a
type AnIndexedSetter i s t a b = Indexed i a (Identity b) -> s -> Identity t
type ASetter' s a = ASetter s s a a
type ASetter s t a b = (a -> Identity b) -> s -> Identity t
mapped :: Functor f => Setter (f a) (f b) a b
lifted :: Monad m => Setter (m a) (m b) a b
contramapped :: Contravariant f => Setter (f b) (f a) a b
argument :: Profunctor p => Setter (p b r) (p a r) a b
setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b
sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b
cloneSetter :: ASetter s t a b -> Setter s t a b
cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b
cloneIndexedSetter :: AnIndexedSetter i s t a b -> IndexedSetter i s t a b
over :: ASetter s t a b -> (a -> b) -> s -> t
set :: ASetter s t a b -> b -> s -> t
set' :: ASetter' s a -> a -> s -> s
assign :: MonadState s m => ASetter s s a b -> b -> m ()
modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m ()
passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a
ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a
censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a
icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a
locally :: MonadReader s m => ASetter s s a b -> (a -> b) -> m r -> m r
ilocally :: MonadReader s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m r -> m r
iover :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
isets :: ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b
imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
assignA :: Arrow p => ASetter s t a b -> p s b -> p s t
mapOf :: ASetter s t a b -> (a -> b) -> s -> t
imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
type AnIndexedLens' i s a = AnIndexedLens i s s a a
type AnIndexedLens i s t a b = Optical (Indexed i) (->) (Pretext (Indexed i) a b) s t a b
type ALens' s a = ALens s s a a
type ALens s t a b = LensLike (Pretext (->) a b) s t a b
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
withLens :: forall s t a b rep (r :: TYPE rep). ALens s t a b -> ((s -> a) -> (s -> b -> t) -> r) -> r
iplens :: (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b
ilens :: (s -> (i, a)) -> (s -> b -> t) -> IndexedLens i s t a b
inside :: Corepresentable p => ALens s t a b -> Lens (p e s) (p e t) (p e a) (p e b)
choosing :: Functor f => LensLike f s t a b -> LensLike f s' t' a b -> LensLike f (Either s s') (Either t t') a b
chosen :: IndexPreservingLens (Either a a) (Either b b) a b
alongside :: LensLike (AlongsideLeft f b') s t a b -> LensLike (AlongsideRight f t) s' t' a' b' -> LensLike f (s, s') (t, t') (a, a') (b, b')
locus :: IndexedComonadStore p => Lens (p a c s) (p b c s) a b
cloneLens :: ALens s t a b -> Lens s t a b
cloneIndexPreservingLens :: ALens s t a b -> IndexPreservingLens s t a b
cloneIndexedLens :: AnIndexedLens i s t a b -> IndexedLens i s t a b
overA :: Arrow ar => LensLike (Context a b) s t a b -> ar a b -> ar s t
storing :: ALens s t a b -> b -> s -> t
devoid :: Over p f Void Void a b
united :: Lens' a ()
head1 :: Traversable1 t => Lens' (t a) a
last1 :: Traversable1 t => Lens' (t a) a
fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b
class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _19 :: Lens s t a b
class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _18 :: Lens s t a b
class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _17 :: Lens s t a b
class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _16 :: Lens s t a b
class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _15 :: Lens s t a b
class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _14 :: Lens s t a b
class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _13 :: Lens s t a b
class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _12 :: Lens s t a b
class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _11 :: Lens s t a b
class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _10 :: Lens s t a b
class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _9 :: Lens s t a b
class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _8 :: Lens s t a b
class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _7 :: Lens s t a b
class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _6 :: Lens s t a b
class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _5 :: Lens s t a b
class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _4 :: Lens s t a b
class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _3 :: Lens s t a b
class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _2 :: Lens s t a b
class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _1 :: Lens s t a b
_1' :: Field1 s t a b => Lens s t a b
_2' :: Field2 s t a b => Lens s t a b
_3' :: Field3 s t a b => Lens s t a b
_4' :: Field4 s t a b => Lens s t a b
_5' :: Field5 s t a b => Lens s t a b
_6' :: Field6 s t a b => Lens s t a b
_7' :: Field7 s t a b => Lens s t a b
_8' :: Field8 s t a b => Lens s t a b
_9' :: Field9 s t a b => Lens s t a b
_10' :: Field10 s t a b => Lens s t a b
_11' :: Field11 s t a b => Lens s t a b
_12' :: Field12 s t a b => Lens s t a b
_13' :: Field13 s t a b => Lens s t a b
_14' :: Field14 s t a b => Lens s t a b
_15' :: Field15 s t a b => Lens s t a b
_16' :: Field16 s t a b => Lens s t a b
_17' :: Field17 s t a b => Lens s t a b
_18' :: Field18 s t a b => Lens s t a b
_19' :: Field19 s t a b => Lens s t a b
type Accessing p m s a = p a (Const m a) -> s -> Const m s
type IndexedGetting i m s a = Indexed i a (Const m a) -> s -> Const m s
type Getting r s a = (a -> Const r a) -> s -> Const r s
to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a
ito :: (Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a
like :: (Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a
ilike :: (Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a
view :: MonadReader s m => Getting a s a -> m a
views :: MonadReader s m => LensLike' (Const r) s a -> (a -> r) -> m r
use :: MonadState s m => Getting a s a -> m a
uses :: MonadState s m => LensLike' (Const r) s a -> (a -> r) -> m r
listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u)
ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u))
listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v)
ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v)
iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a)
iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a)
iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
getting :: (Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a
unto :: (Profunctor p, Bifunctor p, Functor f) => (b -> t) -> Optic p f s t a b
un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s
re :: AReview t b -> Getter b t
review :: MonadReader b m => AReview t b -> m t
reviews :: MonadReader b m => AReview t b -> (t -> r) -> m r
reuse :: MonadState b m => AReview t b -> m t
reuses :: MonadState b m => AReview t b -> (t -> r) -> m r
reviewing :: (Bifunctor p, Functor f) => Optic Tagged Identity s t a b -> Optic' p f t b
type APrism' s a = APrism s s a a
type APrism s t a b = Market a b a (Identity b) -> Market a b s (Identity t)
withPrism :: APrism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
clonePrism :: APrism s t a b -> Prism s t a b
prism :: (b -> t) -> (s -> Either t a) -> Prism s t a b
prism' :: (b -> s) -> (s -> Maybe a) -> Prism s s a b
outside :: Representable p => APrism s t a b -> Lens (p t r) (p s r) (p b r) (p a r)
without :: APrism s t a b -> APrism u v c d -> Prism (Either s u) (Either t v) (Either a c) (Either b d)
aside :: APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b)
below :: Traversable f => APrism' s a -> Prism' (f s) (f a)
isn't :: APrism s t a b -> s -> Bool
matching :: APrism s t a b -> s -> Either t a
_Left :: Prism (Either a c) (Either b c) a b
_Right :: Prism (Either c a) (Either c b) a b
_Just :: Prism (Maybe a) (Maybe b) a b
_Nothing :: Prism' (Maybe a) ()
_Void :: Prism s s a Void
only :: Eq a => a -> Prism' a ()
nearly :: a -> (a -> Bool) -> Prism' a ()
_Show :: (Read a, Show a) => Prism' String a
folding :: Foldable f => (s -> f a) -> Fold s a
ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b
foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
folded :: Foldable f => IndexedFold Int (f a) a
folded64 :: Foldable f => IndexedFold Int64 (f a) a
repeated :: Apply f => LensLike' f a a
replicated :: Int -> Fold a a
cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
unfolded :: (b -> Maybe (a, b)) -> Fold b a
iterated :: Apply f => (a -> a) -> LensLike' f a a
filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a
filteredBy :: (Indexable i p, Applicative f) => Getting (First i) a i -> p a (f a) -> a -> f a
takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
droppingWhile :: (Conjoined p, Profunctor q, Applicative f) => (a -> Bool) -> Optical p q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
worded :: Applicative f => IndexedLensLike' Int f String String
lined :: Applicative f => IndexedLensLike' Int f String String
foldMapOf :: Getting r s a -> (a -> r) -> s -> r
foldOf :: Getting a s a -> s -> a
foldrOf :: Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
foldlOf :: Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
toListOf :: Getting (Endo [a]) s a -> s -> [a]
toNonEmptyOf :: Getting (NonEmptyDList a) s a -> s -> NonEmpty a
andOf :: Getting All s Bool -> s -> Bool
orOf :: Getting Any s Bool -> s -> Bool
anyOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
allOf :: Getting All s a -> (a -> Bool) -> s -> Bool
noneOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()
sequenceAOf_ :: Functor f => Getting (Traversed a f) s (f a) -> s -> f ()
traverse1Of_ :: Functor f => Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
for1Of_ :: Functor f => Getting (TraversedF r f) s a -> s -> (a -> f r) -> f ()
sequence1Of_ :: Functor f => Getting (TraversedF a f) s (f a) -> s -> f ()
mapMOf_ :: Monad m => Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
forMOf_ :: Monad m => Getting (Sequenced r m) s a -> s -> (a -> m r) -> m ()
sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m ()
asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a
msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a
elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
concatMapOf :: Getting [r] s a -> (a -> [r]) -> s -> [r]
concatOf :: Getting [r] s [r] -> s -> [r]
lengthOf :: Getting (Endo (Endo Int)) s a -> s -> Int
firstOf :: Getting (Leftmost a) s a -> s -> Maybe a
first1Of :: Getting (First a) s a -> s -> a
lastOf :: Getting (Rightmost a) s a -> s -> Maybe a
last1Of :: Getting (Last a) s a -> s -> a
nullOf :: Getting All s a -> s -> Bool
notNullOf :: Getting Any s a -> s -> Bool
maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
maximum1Of :: Ord a => Getting (Max a) s a -> s -> a
minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
minimum1Of :: Ord a => Getting (Min a) s a -> s -> a
maximumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
minimumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
findOf :: Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a)
lookupOf :: Eq k => Getting (Endo (Maybe v)) s (k, v) -> k -> s -> Maybe v
foldr1Of :: HasCallStack => Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
foldl1Of :: HasCallStack => Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldrOf' :: Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
foldlOf' :: Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
foldr1Of' :: HasCallStack => Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a
foldl1Of' :: HasCallStack => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldrMOf :: Monad m => Getting (Dual (Endo (r -> m r))) s a -> (a -> r -> m r) -> r -> s -> m r
foldlMOf :: Monad m => Getting (Endo (r -> m r)) s a -> (r -> a -> m r) -> r -> s -> m r
has :: Getting Any s a -> s -> Bool
hasn't :: Getting All s a -> s -> Bool
pre :: Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
ipre :: IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
previews :: MonadReader s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
preuses :: MonadState s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
backwards :: (Profunctor p, Profunctor q) => Optical p q (Backwards f) s t a b -> Optical p q f s t a b
ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m
ifoldrOf :: IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
ifoldlOf :: IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ianyOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
iallOf :: IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f ()
iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f ()
imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()
iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m ()
iconcatMapOf :: IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
ifindOf :: IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a
ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a)
ifoldrOf' :: IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r
ifoldlOf' :: IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r
ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r
itoListOf :: IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
findIndexOf :: IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
findIndicesOf :: IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a
itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f) => (i -> a -> Bool) -> Optical' (Indexed i) q (Const (Endo (f s))) s a -> Optical' p q f s a
idroppingWhile :: (Indexable i p, Profunctor q, Applicative f) => (i -> a -> Bool) -> Optical (Indexed i) q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
foldByOf :: Fold s a -> (a -> a -> a) -> a -> s -> a
foldMapByOf :: Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
class Ord k => TraverseMax k m | m -> k where
- traverseMax :: IndexedTraversal' k (m v) v
class Ord k => TraverseMin k m | m -> k where
- traverseMin :: IndexedTraversal' k (m v) v
type Traversing1' p f s a = Traversing1 p f s s a a
type Traversing' p f s a = Traversing p f s s a a
type Traversing1 p f s t a b = Over p (BazaarT1 p f a b) s t a b
type Traversing p f s t a b = Over p (BazaarT p f a b) s t a b
type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a
type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a
type AnIndexedTraversal1 i s t a b = Over (Indexed i) (Bazaar1 (Indexed i) a b) s t a b
type AnIndexedTraversal i s t a b = Over (Indexed i) (Bazaar (Indexed i) a b) s t a b
type ATraversal1' s a = ATraversal1 s s a a
type ATraversal1 s t a b = LensLike (Bazaar1 (->) a b) s t a b
type ATraversal' s a = ATraversal s s a a
type ATraversal s t a b = LensLike (Bazaar (->) a b) s t a b
traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t
forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t
sequenceAOf :: LensLike f s t (f b) b -> s -> f t
mapMOf :: LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
forMOf :: LensLike (WrappedMonad m) s t a b -> s -> (a -> m b) -> m t
sequenceOf :: LensLike (WrappedMonad m) s t (m b) b -> s -> m t
transposeOf :: LensLike ZipList s t [a] a -> s -> [t]
mapAccumROf :: LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
scanr1Of :: LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t
scanl1Of :: LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t
loci :: Traversal (Bazaar (->) a c s) (Bazaar (->) b c s) a b
iloci :: IndexedTraversal i (Bazaar (Indexed i) a c s) (Bazaar (Indexed i) b c s) a b
partsOf :: Functor f => Traversing (->) f s t a a -> LensLike f s t [a] [a]
ipartsOf :: forall i p f s t a. (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a]
partsOf' :: ATraversal s t a a -> Lens s t [a] [a]
ipartsOf' :: forall i p f s t a. (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a]
unsafePartsOf :: Functor f => Traversing (->) f s t a b -> LensLike f s t [a] [b]
iunsafePartsOf :: forall i p f s t a b. (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b]
unsafePartsOf' :: ATraversal s t a b -> Lens s t [a] [b]
iunsafePartsOf' :: forall i s t a b. Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b]
singular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a
unsafeSingular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b
holesOf :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
holes1Of :: Conjoined p => Over p (Bazaar1 p a a) s t a a -> s -> NonEmpty (Pretext p a a t)
both :: Bitraversable r => Traversal (r a a) (r b b) a b
both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b
beside :: (Representable q, Applicative (Rep q), Applicative f, Bitraversable r) => Optical p q f s t a b -> Optical p q f s' t' a b -> Optical p q f (r s s') (r t t') a b
taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a
dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a
cloneTraversal :: ATraversal s t a b -> Traversal s t a b
cloneIndexPreservingTraversal :: ATraversal s t a b -> IndexPreservingTraversal s t a b
cloneIndexedTraversal :: AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b
cloneTraversal1 :: ATraversal1 s t a b -> Traversal1 s t a b
cloneIndexPreservingTraversal1 :: ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
cloneIndexedTraversal1 :: AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b
itraverseOf :: (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
iforOf :: (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t
imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t
iforMOf :: (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t
imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b
traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b
traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b
ignored :: Applicative f => pafb -> s -> f s
elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a
element :: Traversable t => Int -> IndexedTraversal' Int (t a) a
elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a
elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a
failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t
ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t
failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b
deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b
confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b
traverseByOf :: Traversal s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t
sequenceByOf :: Traversal s t (f b) b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> s -> f t
levels :: Applicative f => Traversing (->) f s t a b -> IndexedLensLike Int f s t (Level () a) (Level () b)
ilevels :: Applicative f => Traversing (Indexed i) f s t a b -> IndexedLensLike Int f s t (Level i a) (Level j b)
type ReifiedPrism' s a = ReifiedPrism s s a a
newtype ReifiedPrism s t a b = Prism {
- runPrism :: Prism s t a b
}
type ReifiedIso' s a = ReifiedIso s s a a
newtype ReifiedIso s t a b = Iso {
- runIso :: Iso s t a b
}
type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a
newtype ReifiedIndexedSetter i s t a b = IndexedSetter {
- runIndexedSetter :: IndexedSetter i s t a b
}
type ReifiedSetter' s a = ReifiedSetter s s a a
newtype ReifiedSetter s t a b = Setter {
- runSetter :: Setter s t a b
}
newtype ReifiedIndexedFold i s a = IndexedFold {
- runIndexedFold :: IndexedFold i s a
}
newtype ReifiedFold s a = Fold {
- runFold :: Fold s a
}
newtype ReifiedIndexedGetter i s a = IndexedGetter {
- runIndexedGetter :: IndexedGetter i s a
}
newtype ReifiedGetter s a = Getter {
- runGetter :: Getter s a
}
type ReifiedTraversal' s a = ReifiedTraversal s s a a
newtype ReifiedTraversal s t a b = Traversal {
- runTraversal :: Traversal s t a b
}
type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a
newtype ReifiedIndexedTraversal i s t a b = IndexedTraversal {
- runIndexedTraversal :: IndexedTraversal i s t a b
}
type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a
newtype ReifiedIndexedLens i s t a b = IndexedLens {
- runIndexedLens :: IndexedLens i s t a b
}
type ReifiedLens' s a = ReifiedLens s s a a
newtype ReifiedLens s t a b = Lens {
- runLens :: Lens s t a b
}
selfIndex :: Indexable a p => p a fb -> a -> fb
reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r
icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
indices :: (Indexable i p, Applicative f) => (i -> Bool) -> Optical' p (Indexed i) f a a
index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a
imapped :: FunctorWithIndex i f => IndexedSetter i (f a) (f b) a b
ifolded :: FoldableWithIndex i f => IndexedFold i (f a) a
itraversed :: TraversableWithIndex i t => IndexedTraversal i (t a) (t b) a b
ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r
ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r
itraverseBy :: TraversableWithIndex i t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b)
itraverseByOf :: IndexedTraversal i s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t
type AnEquality' s a = AnEquality s s a a
type AnEquality s t a b = Identical a (Proxy b) a (Proxy b) -> Identical a (Proxy b) s (Proxy t)
data Identical a b s t where
- Identical :: Identical a b a b
runEq :: AnEquality s t a b -> Identical s t a b
substEq :: forall s t a b rep (r :: TYPE rep). AnEquality s t a b -> ((s ~ a, t ~ b) => r) -> r
mapEq :: forall k1 k2 (s :: k1) (t :: k2) (a :: k1) (b :: k2) (f :: k1 -> Type). AnEquality s t a b -> f s -> f a
fromEq :: AnEquality s t a b -> Equality b a t s
simply :: forall p f s a rep (r :: TYPE rep). (Optic' p f s a -> r) -> Optic' p f s a -> r
simple :: Equality' a a
cloneEquality :: AnEquality s t a b -> Equality s t a b
equality :: (s :~: a) -> (b :~: t) -> Equality s t a b
equality' :: (a :~: b) -> Equality' a b
overEquality :: AnEquality s t a b -> p a b -> p s t
underEquality :: AnEquality s t a b -> p t s -> p b a
fromLeibniz :: (Identical a b a b -> Identical a b s t) -> Equality s t a b
fromLeibniz' :: ((s :~: s) -> s :~: a) -> Equality' s a
withEquality :: forall s t a b rep (r :: TYPE rep). AnEquality s t a b -> ((s :~: a) -> (b :~: t) -> r) -> r
type AnIso' s a = AnIso s s a a
type AnIso s t a b = Exchange a b a (Identity b) -> Exchange a b s (Identity t)
pattern List :: IsList l => [Item l] -> l
pattern Reversed :: Reversing t => t -> t
pattern Swapped :: forall {p} {c} {d}. Swap p => p d c -> p c d
pattern Lazy :: Strict t s => t -> s
pattern Strict :: Strict s t => t -> s
iso :: (s -> a) -> (b -> t) -> Iso s t a b
from :: AnIso s t a b -> Iso b a t s
withIso :: forall s t a b rep (r :: TYPE rep). AnIso s t a b -> ((s -> a) -> (b -> t) -> r) -> r
cloneIso :: AnIso s t a b -> Iso s t a b
au :: Functor f => AnIso s t a b -> ((b -> t) -> f s) -> f a
auf :: (Functor f, Functor g) => AnIso s t a b -> (f t -> g s) -> f b -> g a
xplat :: Optic (Costar ((->) s)) g s t a b -> ((s -> a) -> g b) -> g t
xplatf :: Optic (Costar f) g s t a b -> (f a -> g b) -> f s -> g t
under :: AnIso s t a b -> (t -> s) -> b -> a
enum :: Enum a => Iso' Int a
mapping :: (Functor f, Functor g) => AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
non :: Eq a => a -> Iso' (Maybe a) a
non' :: APrism' a () -> Iso' (Maybe a) a
anon :: a -> (a -> Bool) -> Iso' (Maybe a) a
curried :: Iso ((a, b) -> c) ((d, e) -> f) (a -> b -> c) (d -> e -> f)
uncurried :: Iso (a -> b -> c) (d -> e -> f) ((a, b) -> c) ((d, e) -> f)
flipped :: Iso (a -> b -> c) (a' -> b' -> c') (b -> a -> c) (b' -> a' -> c')
swapped :: Swap p => Iso (p a b) (p c d) (p b a) (p d c)
strict :: Strict lazy strict => Iso' lazy strict
lazy :: Strict lazy strict => Iso' strict lazy
reversed :: Reversing a => Iso' a a
involuted :: (a -> a) -> Iso' a a
magma :: LensLike (Mafic a b) s t a b -> Iso s u (Magma Int t b a) (Magma j u c c)
imagma :: Over (Indexed i) (Molten i a b) s t a b -> Iso s t' (Magma i t b a) (Magma j t' c c)
contramapping :: Contravariant f => AnIso s t a b -> Iso (f a) (f b) (f s) (f t)
dimapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (p a s') (q b t') (p s a') (q t b')
lmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p a x) (q b y) (p s x) (q t y)
rmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p x s) (q y t) (p x a) (q y b)
bimapping :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (f s s') (g t t') (f a a') (g b b')
firsting :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f s x) (g t y) (f a x) (g b y)
seconding :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f x s) (g y t) (f x a) (g y b)
coerced :: forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
class AsEmpty a where
- _Empty :: Prism' a ()
pattern Empty :: AsEmpty s => s
class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _Snoc :: Prism s t (s, a) (t, b)
class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s where
- _Cons :: Prism s t (a, s) (b, t)
cons :: Cons s s a a => a -> s -> s
uncons :: Cons s s a a => s -> Maybe (a, s)
_head :: Cons s s a a => Traversal' s a
_tail :: Cons s s a a => Traversal' s s
_init :: Snoc s s a a => Traversal' s s
_last :: Snoc s s a a => Traversal' s a
snoc :: Snoc s s a a => s -> a -> s
unsnoc :: Snoc s s a a => s -> Maybe (s, a)
class (Rewrapped s t, Rewrapped t s) => Rewrapping s t
class Wrapped s => Rewrapped (s :: *) (t :: *)
class Wrapped s where
- type Unwrapped s :: *
- _Wrapped' :: Iso' s (Unwrapped s)
pattern Unwrapped :: Rewrapped t t => t -> Unwrapped t
pattern Wrapped :: Rewrapped s s => Unwrapped s -> s
_GWrapped' :: (Generic s, D1 d (C1 c (S1 s' (Rec0 a))) ~ Rep s, Unwrapped s ~ GUnwrapped (Rep s)) => Iso' s (Unwrapped s)
_Unwrapped' :: Wrapped s => Iso' (Unwrapped s) s
_Wrapped :: Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
_Unwrapped :: Rewrapping s t => Iso (Unwrapped t) (Unwrapped s) t s
op :: Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
_Wrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' s (Unwrapped s)
_Unwrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' (Unwrapped s) s
_Wrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso s t (Unwrapped s) (Unwrapped t)
_Unwrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso (Unwrapped t) (Unwrapped s) t s
ala :: (Functor f, Rewrapping s t) => (Unwrapped s -> s) -> ((Unwrapped t -> t) -> f s) -> f (Unwrapped s)
alaf :: (Functor f, Functor g, Rewrapping s t) => (Unwrapped s -> s) -> (f t -> g s) -> f (Unwrapped t) -> g (Unwrapped s)
class (Magnified m ~ Magnified n, MonadReader b m, MonadReader a n) => Magnify m n b a | m -> b, n -> a, m a -> n, n b -> m where
- magnify :: ((Functor (Magnified m c), Contravariant (Magnified m c)) => LensLike' (Magnified m c) a b) -> m c -> n c
class (MonadState s m, MonadState t n) => Zoom m n s t | m -> s, n -> t, m t -> n, n s -> m where
- zoom :: LensLike' (Zoomed m c) t s -> m c -> n c
type family Magnified (m :: * -> *) :: * -> * -> *
type family Zoomed (m :: * -> *) :: * -> * -> *
class GPlated1 f g
class GPlated a g
class Plated a where
- plate :: Traversal' a a
deep :: (Conjoined p, Applicative f, Plated s) => Traversing p f s s a b -> Over p f s s a b
children :: Plated a => a -> [a]
rewrite :: Plated a => (a -> Maybe a) -> a -> a
rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b
rewriteOn :: Plated a => ASetter s t a a -> (a -> Maybe a) -> s -> t
rewriteOnOf :: ASetter s t a b -> ASetter a b a b -> (b -> Maybe a) -> s -> t
rewriteM :: (Monad m, Plated a) => (a -> m (Maybe a)) -> a -> m a
rewriteMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
rewriteMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m (Maybe a)) -> s -> m t
rewriteMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> s -> m t
universe :: Plated a => a -> [a]
universeOf :: Getting [a] a a -> a -> [a]
universeOn :: Plated a => Getting [a] s a -> s -> [a]
universeOnOf :: Getting [a] s a -> Getting [a] a a -> s -> [a]
cosmos :: Plated a => Fold a a
cosmosOf :: (Applicative f, Contravariant f) => LensLike' f a a -> LensLike' f a a
cosmosOn :: (Applicative f, Contravariant f, Plated a) => LensLike' f s a -> LensLike' f s a
cosmosOnOf :: (Applicative f, Contravariant f) => LensLike' f s a -> LensLike' f a a -> LensLike' f s a
transform :: Plated a => (a -> a) -> a -> a
transformOn :: Plated a => ASetter s t a a -> (a -> a) -> s -> t
transformOf :: ASetter a b a b -> (b -> b) -> a -> b
transformOnOf :: ASetter s t a b -> ASetter a b a b -> (b -> b) -> s -> t
transformM :: (Monad m, Plated a) => (a -> m a) -> a -> m a
transformMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m a) -> s -> m t
transformMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
transformMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m b) -> s -> m t
contexts :: Plated a => a -> [Context a a a]
contextsOf :: ATraversal' a a -> a -> [Context a a a]
contextsOn :: Plated a => ATraversal s t a a -> s -> [Context a a t]
contextsOnOf :: ATraversal s t a a -> ATraversal' a a -> s -> [Context a a t]
holes :: Plated a => a -> [Pretext (->) a a a]
holesOn :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
holesOnOf :: Conjoined p => LensLike (Bazaar p r r) s t a b -> Over p (Bazaar p r r) a b r r -> s -> [Pretext p r r t]
paraOf :: Getting (Endo [a]) a a -> (a -> [r] -> r) -> a -> r
para :: Plated a => (a -> [r] -> r) -> a -> r
composOpFold :: Plated a => b -> (b -> b -> b) -> (a -> b) -> a -> b
parts :: Plated a => Lens' a [a]
gplate :: (Generic a, GPlated a (Rep a)) => Traversal' a a
gplate1 :: (Generic1 f, GPlated1 f (Rep1 f)) => Traversal' (f a) (f a)
class Each s t a b | s -> a, t -> b, s b -> t, t a -> s where
- each :: Traversal s t a b
class Ixed m => At m where
- at :: Index m -> Lens' m (Maybe (IxValue m))
class Ixed m where
- ix :: Index m -> Traversal' m (IxValue m)
type family IxValue (m :: *) :: *
class Contains m where
- contains :: Index m -> Lens' m Bool
type family Index (s :: *) :: *
icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool
iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m)
ixAt :: At m => Index m -> Traversal' m (IxValue m)
sans :: At m => Index m -> m -> m
iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m))
makePrisms :: Name -> DecsQ
makeClassyPrisms :: Name -> DecsQ
type ClassyNamer = Name -> Maybe (Name, Name)
data DefName
- = TopName Name
- | MethodName Name Name
type FieldNamer = Name -> [Name] -> Name -> [DefName]
data LensRules
simpleLenses :: Lens' LensRules Bool
generateSignatures :: Lens' LensRules Bool
generateUpdateableOptics :: Lens' LensRules Bool
generateLazyPatterns :: Lens' LensRules Bool
createClass :: Lens' LensRules Bool
lensField :: Lens' LensRules FieldNamer
lensClass :: Lens' LensRules ClassyNamer
lensRules :: LensRules
underscoreNoPrefixNamer :: FieldNamer
lensRulesFor :: [(String, String)] -> LensRules
lookingupNamer :: [(String, String)] -> FieldNamer
mappingNamer :: (String -> [String]) -> FieldNamer
classyRules :: LensRules
classyRules_ :: LensRules
makeLenses :: Name -> DecsQ
makeClassy :: Name -> DecsQ
makeClassy_ :: Name -> DecsQ
makeLensesFor :: [(String, String)] -> Name -> DecsQ
makeClassyFor :: String -> String -> [(String, String)] -> Name -> DecsQ
makeLensesWith :: LensRules -> Name -> DecsQ
declareLenses :: DecsQ -> DecsQ
declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ
declareClassy :: DecsQ -> DecsQ
declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ
declarePrisms :: DecsQ -> DecsQ
declareWrapped :: DecsQ -> DecsQ
declareFields :: DecsQ -> DecsQ
declareLensesWith :: LensRules -> DecsQ -> DecsQ
makeWrapped :: Name -> DecsQ
underscoreFields :: LensRules
underscoreNamer :: FieldNamer
camelCaseFields :: LensRules
camelCaseNamer :: FieldNamer
classUnderscoreNoPrefixFields :: LensRules
classUnderscoreNoPrefixNamer :: FieldNamer
abbreviatedFields :: LensRules
abbreviatedNamer :: FieldNamer
makeFields :: Name -> DecsQ
makeFieldsNoPrefix :: Name -> DecsQ
defaultFieldRules :: LensRules

Documentation

class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where Source #

Functors representing data structures that can be transformed to structures of the same shape by performing an Applicative (or, therefore, Monad) action on each element from left to right.

A more detailed description of what same shape means, the various methods, how traversals are constructed, and example advanced use-cases can be found in the Overview section of Data.Traversable.

For the class laws see the Laws section of Data.Traversable.

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) Source #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

Examples

Expand

Basic usage:

In the first two examples we show each evaluated action mapping to the output structure.

>>> traverse Just [1,2,3,4]
Just [1,2,3,4]

>>> traverse id [Right 1, Right 2, Right 3, Right 4]
Right [1,2,3,4]

In the next examples, we show that Nothing and Left values short circuit the created structure.

>>> traverse (const Nothing) [1,2,3,4]
Nothing

>>> traverse (\x -> if odd x then Just x else Nothing)  [1,2,3,4]
Nothing

>>> traverse id [Right 1, Right 2, Right 3, Right 4, Left 0]
Left 0

Instances

Instances details

Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) Source # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) Source # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) Source # sequence :: Monad m => ZipList (m a) -> m (ZipList a) Source #
Traversable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) Source # sequenceA :: Applicative f => Complex (f a) -> f (Complex a) Source # mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) Source # sequence :: Monad m => Complex (m a) -> m (Complex a) Source #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) Source # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) Source # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) Source # sequence :: Monad m => Identity (m a) -> m (Identity a) Source #
Traversable First	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) Source # sequenceA :: Applicative f => First (f a) -> f (First a) Source # mapM :: Monad m => (a -> m b) -> First a -> m (First b) Source # sequence :: Monad m => First (m a) -> m (First a) Source #
Traversable Last	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) Source # sequenceA :: Applicative f => Last (f a) -> f (Last a) Source # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) Source # sequence :: Monad m => Last (m a) -> m (Last a) Source #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) Source # sequenceA :: Applicative f => Down (f a) -> f (Down a) Source # mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) Source # sequence :: Monad m => Down (m a) -> m (Down a) Source #
Traversable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) Source # sequenceA :: Applicative f => First (f a) -> f (First a) Source # mapM :: Monad m => (a -> m b) -> First a -> m (First b) Source # sequence :: Monad m => First (m a) -> m (First a) Source #
Traversable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) Source # sequenceA :: Applicative f => Last (f a) -> f (Last a) Source # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) Source # sequence :: Monad m => Last (m a) -> m (Last a) Source #
Traversable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) Source # sequenceA :: Applicative f => Max (f a) -> f (Max a) Source # mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) Source # sequence :: Monad m => Max (m a) -> m (Max a) Source #
Traversable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) Source # sequenceA :: Applicative f => Min (f a) -> f (Min a) Source # mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) Source # sequence :: Monad m => Min (m a) -> m (Min a) Source #
Traversable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) Source # sequenceA :: Applicative f => Option (f a) -> f (Option a) Source # mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) Source # sequence :: Monad m => Option (m a) -> m (Option a) Source #
Traversable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) Source # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) Source # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) Source # sequence :: Monad m => Dual (m a) -> m (Dual a) Source #
Traversable Product	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) Source # sequenceA :: Applicative f => Product (f a) -> f (Product a) Source # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) Source # sequence :: Monad m => Product (m a) -> m (Product a) Source #
Traversable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) Source # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) Source # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) Source # sequence :: Monad m => Sum (m a) -> m (Sum a) Source #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) Source # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) Source # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) Source # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) Source #
Traversable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) Source # sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) Source # mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) Source # sequence :: Monad m => Par1 (m a) -> m (Par1 a) Source #
Traversable IntMap	Traverses in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) Source # sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) Source # mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) Source # sequence :: Monad m => IntMap (m a) -> m (IntMap a) Source #
Traversable Digit
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) Source # sequenceA :: Applicative f => Digit (f a) -> f (Digit a) Source # mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) Source # sequence :: Monad m => Digit (m a) -> m (Digit a) Source #
Traversable Elem
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) Source # sequenceA :: Applicative f => Elem (f a) -> f (Elem a) Source # mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) Source # sequence :: Monad m => Elem (m a) -> m (Elem a) Source #
Traversable FingerTree
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) Source # sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) Source # mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) Source # sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) Source #
Traversable Node
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) Source # sequenceA :: Applicative f => Node (f a) -> f (Node a) Source # mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) Source # sequence :: Monad m => Node (m a) -> m (Node a) Source #
Traversable Seq
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) Source # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) Source # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) Source # sequence :: Monad m => Seq (m a) -> m (Seq a) Source #
Traversable ViewL
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) Source # sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) Source # mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) Source # sequence :: Monad m => ViewL (m a) -> m (ViewL a) Source #
Traversable ViewR
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) Source # sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) Source # mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) Source # sequence :: Monad m => ViewR (m a) -> m (ViewR a) Source #
Traversable Tree
Instance details Defined in Data.Tree Methods traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b) Source # sequenceA :: Applicative f => Tree (f a) -> f (Tree a) Source # mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b) Source # sequence :: Monad m => Tree (m a) -> m (Tree a) Source #
Traversable Deque Source #
Instance details Defined in Control.Lens.Internal.Deque Methods traverse :: Applicative f => (a -> f b) -> Deque a -> f (Deque b) Source # sequenceA :: Applicative f => Deque (f a) -> f (Deque a) Source # mapM :: Monad m => (a -> m b) -> Deque a -> m (Deque b) Source # sequence :: Monad m => Deque (m a) -> m (Deque a) Source #
Traversable Array
Instance details Defined in Data.Primitive.Array Methods traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b) Source # sequenceA :: Applicative f => Array (f a) -> f (Array a) Source # mapM :: Monad m => (a -> m b) -> Array a -> m (Array b) Source # sequence :: Monad m => Array (m a) -> m (Array a) Source #
Traversable SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods traverse :: Applicative f => (a -> f b) -> SmallArray a -> f (SmallArray b) Source # sequenceA :: Applicative f => SmallArray (f a) -> f (SmallArray a) Source # mapM :: Monad m => (a -> m b) -> SmallArray a -> m (SmallArray b) Source # sequence :: Monad m => SmallArray (m a) -> m (SmallArray a) Source #
Traversable Maybe
Instance details Defined in Data.Strict.Maybe Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) Source # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) Source # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) Source # sequence :: Monad m => Maybe (m a) -> m (Maybe a) Source #
Traversable Vector
Instance details Defined in Data.Vector Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) Source # sequenceA :: Applicative f => Vector (f a) -> f (Vector a) Source # mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) Source # sequence :: Monad m => Vector (m a) -> m (Vector a) Source #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) Source # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) Source # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) Source # sequence :: Monad m => Maybe (m a) -> m (Maybe a) Source #
Traversable Solo	Since: base-4.15
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Solo a -> f (Solo b) Source # sequenceA :: Applicative f => Solo (f a) -> f (Solo a) Source # mapM :: Monad m => (a -> m b) -> Solo a -> m (Solo b) Source # sequence :: Monad m => Solo (m a) -> m (Solo a) Source #
Traversable []	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] Source # sequenceA :: Applicative f => [f a] -> f [a] Source # mapM :: Monad m => (a -> m b) -> [a] -> m [b] Source # sequence :: Monad m => [m a] -> m [a] Source #
Traversable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) Source # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) Source # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) Source # sequence :: Monad m => Either a (m a0) -> m (Either a a0) Source #
Traversable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b) Source # sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a) Source # mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b) Source # sequence :: Monad m => Proxy (m a) -> m (Proxy a) Source #
Traversable (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a0 -> f b) -> Arg a a0 -> f (Arg a b) Source # sequenceA :: Applicative f => Arg a (f a0) -> f (Arg a a0) Source # mapM :: Monad m => (a0 -> m b) -> Arg a a0 -> m (Arg a b) Source # sequence :: Monad m => Arg a (m a0) -> m (Arg a a0) Source #
Ix i => Traversable (Array i)	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) Source # sequenceA :: Applicative f => Array i (f a) -> f (Array i a) Source # mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) Source # sequence :: Monad m => Array i (m a) -> m (Array i a) Source #
Traversable (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) Source # sequenceA :: Applicative f => U1 (f a) -> f (U1 a) Source # mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) Source # sequence :: Monad m => U1 (m a) -> m (U1 a) Source #
Traversable (UAddr :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) Source # sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) Source # mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) Source # sequence :: Monad m => UAddr (m a) -> m (UAddr a) Source #
Traversable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) Source # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) Source # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) Source # sequence :: Monad m => UChar (m a) -> m (UChar a) Source #
Traversable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) Source # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) Source # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) Source # sequence :: Monad m => UDouble (m a) -> m (UDouble a) Source #
Traversable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) Source # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) Source # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) Source # sequence :: Monad m => UFloat (m a) -> m (UFloat a) Source #
Traversable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) Source # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) Source # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) Source # sequence :: Monad m => UInt (m a) -> m (UInt a) Source #
Traversable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) Source # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) Source # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) Source # sequence :: Monad m => UWord (m a) -> m (UWord a) Source #
Traversable (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) Source # sequenceA :: Applicative f => V1 (f a) -> f (V1 a) Source # mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) Source # sequence :: Monad m => V1 (m a) -> m (V1 a) Source #
Traversable (Map k)	Traverses in order of increasing key.
Instance details Defined in Data.Map.Internal Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) Source # sequenceA :: Applicative f => Map k (f a) -> f (Map k a) Source # mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) Source # sequence :: Monad m => Map k (m a) -> m (Map k a) Source #
(Monad m, Traversable m) => Traversable (CatchT m)
Instance details Defined in Control.Monad.Catch.Pure Methods traverse :: Applicative f => (a -> f b) -> CatchT m a -> f (CatchT m b) Source # sequenceA :: Applicative f => CatchT m (f a) -> f (CatchT m a) Source # mapM :: Monad m0 => (a -> m0 b) -> CatchT m a -> m0 (CatchT m b) Source # sequence :: Monad m0 => CatchT m (m0 a) -> m0 (CatchT m a) Source #
Traversable f => Traversable (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods traverse :: Applicative f0 => (a -> f0 b) -> Cofree f a -> f0 (Cofree f b) Source # sequenceA :: Applicative f0 => Cofree f (f0 a) -> f0 (Cofree f a) Source # mapM :: Monad m => (a -> m b) -> Cofree f a -> m (Cofree f b) Source # sequence :: Monad m => Cofree f (m a) -> m (Cofree f a) Source #
Traversable w => Traversable (CoiterT w)
Instance details Defined in Control.Comonad.Trans.Coiter Methods traverse :: Applicative f => (a -> f b) -> CoiterT w a -> f (CoiterT w b) Source # sequenceA :: Applicative f => CoiterT w (f a) -> f (CoiterT w a) Source # mapM :: Monad m => (a -> m b) -> CoiterT w a -> m (CoiterT w b) Source # sequence :: Monad m => CoiterT w (m a) -> m (CoiterT w a) Source #
Traversable f => Traversable (Free f)
Instance details Defined in Control.Monad.Free Methods traverse :: Applicative f0 => (a -> f0 b) -> Free f a -> f0 (Free f b) Source # sequenceA :: Applicative f0 => Free f (f0 a) -> f0 (Free f a) Source # mapM :: Monad m => (a -> m b) -> Free f a -> m (Free f b) Source # sequence :: Monad m => Free f (m a) -> m (Free f a) Source #
Traversable f => Traversable (F f)
Instance details Defined in Control.Monad.Free.Church Methods traverse :: Applicative f0 => (a -> f0 b) -> F f a -> f0 (F f b) Source # sequenceA :: Applicative f0 => F f (f0 a) -> f0 (F f a) Source # mapM :: Monad m => (a -> m b) -> F f a -> m (F f b) Source # sequence :: Monad m => F f (m a) -> m (F f a) Source #
(Monad m, Traversable m) => Traversable (IterT m)
Instance details Defined in Control.Monad.Trans.Iter Methods traverse :: Applicative f => (a -> f b) -> IterT m a -> f (IterT m b) Source # sequenceA :: Applicative f => IterT m (f a) -> f (IterT m a) Source # mapM :: Monad m0 => (a -> m0 b) -> IterT m a -> m0 (IterT m b) Source # sequence :: Monad m0 => IterT m (m0 a) -> m0 (IterT m a) Source #
Traversable f => Traversable (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods traverse :: Applicative f0 => (a -> f0 b) -> Yoneda f a -> f0 (Yoneda f b) Source # sequenceA :: Applicative f0 => Yoneda f (f0 a) -> f0 (Yoneda f a) Source # mapM :: Monad m => (a -> m b) -> Yoneda f a -> m (Yoneda f b) Source # sequence :: Monad m => Yoneda f (m a) -> m (Yoneda f a) Source #
Traversable (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods traverse :: Applicative f => (a -> f b) -> Level i a -> f (Level i b) Source # sequenceA :: Applicative f => Level i (f a) -> f (Level i a) Source # mapM :: Monad m => (a -> m b) -> Level i a -> m (Level i b) Source # sequence :: Monad m => Level i (m a) -> m (Level i a) Source #
Traversable (Either e)
Instance details Defined in Data.Strict.Either Methods traverse :: Applicative f => (a -> f b) -> Either e a -> f (Either e b) Source # sequenceA :: Applicative f => Either e (f a) -> f (Either e a) Source # mapM :: Monad m => (a -> m b) -> Either e a -> m (Either e b) Source # sequence :: Monad m => Either e (m a) -> m (Either e a) Source #
Traversable (These a)
Instance details Defined in Data.Strict.These Methods traverse :: Applicative f => (a0 -> f b) -> These a a0 -> f (These a b) Source # sequenceA :: Applicative f => These a (f a0) -> f (These a a0) Source # mapM :: Monad m => (a0 -> m b) -> These a a0 -> m (These a b) Source # sequence :: Monad m => These a (m a0) -> m (These a a0) Source #
Traversable (Pair e)
Instance details Defined in Data.Strict.Tuple Methods traverse :: Applicative f => (a -> f b) -> Pair e a -> f (Pair e b) Source # sequenceA :: Applicative f => Pair e (f a) -> f (Pair e a) Source # mapM :: Monad m => (a -> m b) -> Pair e a -> m (Pair e b) Source # sequence :: Monad m => Pair e (m a) -> m (Pair e a) Source #
Traversable (These a)
Instance details Defined in Data.These Methods traverse :: Applicative f => (a0 -> f b) -> These a a0 -> f (These a b) Source # sequenceA :: Applicative f => These a (f a0) -> f (These a a0) Source # mapM :: Monad m => (a0 -> m b) -> These a a0 -> m (These a b) Source # sequence :: Monad m => These a (m a0) -> m (These a a0) Source #
Traversable f => Traversable (Lift f)
Instance details Defined in Control.Applicative.Lift Methods traverse :: Applicative f0 => (a -> f0 b) -> Lift f a -> f0 (Lift f b) Source # sequenceA :: Applicative f0 => Lift f (f0 a) -> f0 (Lift f a) Source # mapM :: Monad m => (a -> m b) -> Lift f a -> m (Lift f b) Source # sequence :: Monad m => Lift f (m a) -> m (Lift f a) Source #
Traversable f => Traversable (ListT f)
Instance details Defined in Control.Monad.Trans.List Methods traverse :: Applicative f0 => (a -> f0 b) -> ListT f a -> f0 (ListT f b) Source # sequenceA :: Applicative f0 => ListT f (f0 a) -> f0 (ListT f a) Source # mapM :: Monad m => (a -> m b) -> ListT f a -> m (ListT f b) Source # sequence :: Monad m => ListT f (m a) -> m (ListT f a) Source #
Traversable f => Traversable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods traverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 (MaybeT f b) Source # sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 (MaybeT f a) Source # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) Source # sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) Source #
Traversable (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b) Source # sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a) Source # mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b) Source # sequence :: Monad m => HashMap k (m a) -> m (HashMap k a) Source #
Traversable ((,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> (a, a0) -> f (a, b) Source # sequenceA :: Applicative f => (a, f a0) -> f (a, a0) Source # mapM :: Monad m => (a0 -> m b) -> (a, a0) -> m (a, b) Source # sequence :: Monad m => (a, m a0) -> m (a, a0) Source #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) Source # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) Source # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) Source # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) Source #
Traversable f => Traversable (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Ap f a -> f0 (Ap f b) Source # sequenceA :: Applicative f0 => Ap f (f0 a) -> f0 (Ap f a) Source # mapM :: Monad m => (a -> m b) -> Ap f a -> m (Ap f b) Source # sequence :: Monad m => Ap f (m a) -> m (Ap f a) Source #
Traversable f => Traversable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) Source # sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 (Alt f a) Source # mapM :: Monad m => (a -> m b) -> Alt f a -> m (Alt f b) Source # sequence :: Monad m => Alt f (m a) -> m (Alt f a) Source #
Traversable f => Traversable (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) Source # sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 (Rec1 f a) Source # mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) Source # sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a) Source #
Bitraversable p => Traversable (Fix p)
Instance details Defined in Data.Bifunctor.Fix Methods traverse :: Applicative f => (a -> f b) -> Fix p a -> f (Fix p b) Source # sequenceA :: Applicative f => Fix p (f a) -> f (Fix p a) Source # mapM :: Monad m => (a -> m b) -> Fix p a -> m (Fix p b) Source # sequence :: Monad m => Fix p (m a) -> m (Fix p a) Source #
Bitraversable p => Traversable (Join p)
Instance details Defined in Data.Bifunctor.Join Methods traverse :: Applicative f => (a -> f b) -> Join p a -> f (Join p b) Source # sequenceA :: Applicative f => Join p (f a) -> f (Join p a) Source # mapM :: Monad m => (a -> m b) -> Join p a -> m (Join p b) Source # sequence :: Monad m => Join p (m a) -> m (Join p a) Source #
Traversable w => Traversable (EnvT e w)
Instance details Defined in Control.Comonad.Trans.Env Methods traverse :: Applicative f => (a -> f b) -> EnvT e w a -> f (EnvT e w b) Source # sequenceA :: Applicative f => EnvT e w (f a) -> f (EnvT e w a) Source # mapM :: Monad m => (a -> m b) -> EnvT e w a -> m (EnvT e w b) Source # sequence :: Monad m => EnvT e w (m a) -> m (EnvT e w a) Source #
Traversable f => Traversable (CofreeF f a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods traverse :: Applicative f0 => (a0 -> f0 b) -> CofreeF f a a0 -> f0 (CofreeF f a b) Source # sequenceA :: Applicative f0 => CofreeF f a (f0 a0) -> f0 (CofreeF f a a0) Source # mapM :: Monad m => (a0 -> m b) -> CofreeF f a a0 -> m (CofreeF f a b) Source # sequence :: Monad m => CofreeF f a (m a0) -> m (CofreeF f a a0) Source #
(Traversable f, Traversable w) => Traversable (CofreeT f w)
Instance details Defined in Control.Comonad.Trans.Cofree Methods traverse :: Applicative f0 => (a -> f0 b) -> CofreeT f w a -> f0 (CofreeT f w b) Source # sequenceA :: Applicative f0 => CofreeT f w (f0 a) -> f0 (CofreeT f w a) Source # mapM :: Monad m => (a -> m b) -> CofreeT f w a -> m (CofreeT f w b) Source # sequence :: Monad m => CofreeT f w (m a) -> m (CofreeT f w a) Source #
Traversable f => Traversable (FreeF f a)
Instance details Defined in Control.Monad.Trans.Free Methods traverse :: Applicative f0 => (a0 -> f0 b) -> FreeF f a a0 -> f0 (FreeF f a b) Source # sequenceA :: Applicative f0 => FreeF f a (f0 a0) -> f0 (FreeF f a a0) Source # mapM :: Monad m => (a0 -> m b) -> FreeF f a a0 -> m (FreeF f a b) Source # sequence :: Monad m => FreeF f a (m a0) -> m (FreeF f a a0) Source #
(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods traverse :: Applicative f0 => (a -> f0 b) -> FreeT f m a -> f0 (FreeT f m b) Source # sequenceA :: Applicative f0 => FreeT f m (f0 a) -> f0 (FreeT f m a) Source # mapM :: Monad m0 => (a -> m0 b) -> FreeT f m a -> m0 (FreeT f m b) Source # sequence :: Monad m0 => FreeT f m (m0 a) -> m0 (FreeT f m a) Source #
Traversable f => Traversable (AlongsideLeft f b) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods traverse :: Applicative f0 => (a -> f0 b0) -> AlongsideLeft f b a -> f0 (AlongsideLeft f b b0) Source # sequenceA :: Applicative f0 => AlongsideLeft f b (f0 a) -> f0 (AlongsideLeft f b a) Source # mapM :: Monad m => (a -> m b0) -> AlongsideLeft f b a -> m (AlongsideLeft f b b0) Source # sequence :: Monad m => AlongsideLeft f b (m a) -> m (AlongsideLeft f b a) Source #
Traversable f => Traversable (AlongsideRight f a) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods traverse :: Applicative f0 => (a0 -> f0 b) -> AlongsideRight f a a0 -> f0 (AlongsideRight f a b) Source # sequenceA :: Applicative f0 => AlongsideRight f a (f0 a0) -> f0 (AlongsideRight f a a0) Source # mapM :: Monad m => (a0 -> m b) -> AlongsideRight f a a0 -> m (AlongsideRight f a b) Source # sequence :: Monad m => AlongsideRight f a (m a0) -> m (AlongsideRight f a a0) Source #
Traversable (Baz t b)
Instance details Defined in Data.Profunctor.Traversing Methods traverse :: Applicative f => (a -> f b0) -> Baz t b a -> f (Baz t b b0) Source # sequenceA :: Applicative f => Baz t b (f a) -> f (Baz t b a) Source # mapM :: Monad m => (a -> m b0) -> Baz t b a -> m (Baz t b b0) Source # sequence :: Monad m => Baz t b (m a) -> m (Baz t b a) Source #
Traversable (Tagged s)
Instance details Defined in Data.Tagged Methods traverse :: Applicative f => (a -> f b) -> Tagged s a -> f (Tagged s b) Source # sequenceA :: Applicative f => Tagged s (f a) -> f (Tagged s a) Source # mapM :: Monad m => (a -> m b) -> Tagged s a -> m (Tagged s b) Source # sequence :: Monad m => Tagged s (m a) -> m (Tagged s a) Source #
Traversable f => Traversable (Backwards f)	Derived instance.
Instance details Defined in Control.Applicative.Backwards Methods traverse :: Applicative f0 => (a -> f0 b) -> Backwards f a -> f0 (Backwards f b) Source # sequenceA :: Applicative f0 => Backwards f (f0 a) -> f0 (Backwards f a) Source # mapM :: Monad m => (a -> m b) -> Backwards f a -> m (Backwards f b) Source # sequence :: Monad m => Backwards f (m a) -> m (Backwards f a) Source #
Traversable f => Traversable (ErrorT e f)
Instance details Defined in Control.Monad.Trans.Error Methods traverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 (ErrorT e f b) Source # sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 (ErrorT e f a) Source # mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b) Source # sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a) Source #
Traversable f => Traversable (ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods traverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 (ExceptT e f b) Source # sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 (ExceptT e f a) Source # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) Source # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) Source #
Traversable f => Traversable (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods traverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) Source # sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 (IdentityT f a) Source # mapM :: Monad m => (a -> m b) -> IdentityT f a -> m (IdentityT f b) Source # sequence :: Monad m => IdentityT f (m a) -> m (IdentityT f a) Source #
Traversable f => Traversable (WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods traverse :: Applicative f0 => (a -> f0 b) -> WriterT w f a -> f0 (WriterT w f b) Source # sequenceA :: Applicative f0 => WriterT w f (f0 a) -> f0 (WriterT w f a) Source # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b) Source # sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a) Source #
Traversable f => Traversable (WriterT w f)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods traverse :: Applicative f0 => (a -> f0 b) -> WriterT w f a -> f0 (WriterT w f b) Source # sequenceA :: Applicative f0 => WriterT w f (f0 a) -> f0 (WriterT w f a) Source # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b) Source # sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a) Source #
Traversable (Constant a :: Type -> Type)
Instance details Defined in Data.Functor.Constant Methods traverse :: Applicative f => (a0 -> f b) -> Constant a a0 -> f (Constant a b) Source # sequenceA :: Applicative f => Constant a (f a0) -> f (Constant a a0) Source # mapM :: Monad m => (a0 -> m b) -> Constant a a0 -> m (Constant a b) Source # sequence :: Monad m => Constant a (m a0) -> m (Constant a a0) Source #
Traversable f => Traversable (Reverse f)	Traverse from right to left.
Instance details Defined in Data.Functor.Reverse Methods traverse :: Applicative f0 => (a -> f0 b) -> Reverse f a -> f0 (Reverse f b) Source # sequenceA :: Applicative f0 => Reverse f (f0 a) -> f0 (Reverse f a) Source # mapM :: Monad m => (a -> m b) -> Reverse f a -> m (Reverse f b) Source # sequence :: Monad m => Reverse f (m a) -> m (Reverse f a) Source #
(Traversable f, Traversable g) => Traversable (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods traverse :: Applicative f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b) Source # sequenceA :: Applicative f0 => Product f g (f0 a) -> f0 (Product f g a) Source # mapM :: Monad m => (a -> m b) -> Product f g a -> m (Product f g b) Source # sequence :: Monad m => Product f g (m a) -> m (Product f g a) Source #
(Traversable f, Traversable g) => Traversable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods traverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) Source # sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 (Sum f g a) Source # mapM :: Monad m => (a -> m b) -> Sum f g a -> m (Sum f g b) Source # sequence :: Monad m => Sum f g (m a) -> m (Sum f g a) Source #
(Traversable f, Traversable g) => Traversable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) Source # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((f :: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) Source # sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a) Source #
(Traversable f, Traversable g) => Traversable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) Source # sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) Source # sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) Source #
Traversable (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) Source # sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) Source # mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) Source # sequence :: Monad m => K1 i c (m a) -> m (K1 i c a) Source #
Traversable (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods traverse :: Applicative f => (a -> f b0) -> Magma i t b a -> f (Magma i t b b0) Source # sequenceA :: Applicative f => Magma i t b (f a) -> f (Magma i t b a) Source # mapM :: Monad m => (a -> m b0) -> Magma i t b a -> m (Magma i t b b0) Source # sequence :: Monad m => Magma i t b (m a) -> m (Magma i t b a) Source #
Traversable (Forget r a :: Type -> Type)
Instance details Defined in Data.Profunctor.Types Methods traverse :: Applicative f => (a0 -> f b) -> Forget r a a0 -> f (Forget r a b) Source # sequenceA :: Applicative f => Forget r a (f a0) -> f (Forget r a a0) Source # mapM :: Monad m => (a0 -> m b) -> Forget r a a0 -> m (Forget r a b) Source # sequence :: Monad m => Forget r a (m a0) -> m (Forget r a a0) Source #
(Traversable f, Traversable g) => Traversable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) Source # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) Source # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) Source # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) Source #
(Traversable f, Traversable g) => Traversable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) Source # sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a) Source # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) Source # sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) Source #
Traversable f => Traversable (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) Source # sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 (M1 i c f a) Source # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) Source # sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a) Source #
Traversable (Clown f a :: Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Clown f a a0 -> f0 (Clown f a b) Source # sequenceA :: Applicative f0 => Clown f a (f0 a0) -> f0 (Clown f a a0) Source # mapM :: Monad m => (a0 -> m b) -> Clown f a a0 -> m (Clown f a b) Source # sequence :: Monad m => Clown f a (m a0) -> m (Clown f a a0) Source #
Bitraversable p => Traversable (Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods traverse :: Applicative f => (a0 -> f b) -> Flip p a a0 -> f (Flip p a b) Source # sequenceA :: Applicative f => Flip p a (f a0) -> f (Flip p a a0) Source # mapM :: Monad m => (a0 -> m b) -> Flip p a a0 -> m (Flip p a b) Source # sequence :: Monad m => Flip p a (m a0) -> m (Flip p a a0) Source #
Traversable g => Traversable (Joker g a)
Instance details Defined in Data.Bifunctor.Joker Methods traverse :: Applicative f => (a0 -> f b) -> Joker g a a0 -> f (Joker g a b) Source # sequenceA :: Applicative f => Joker g a (f a0) -> f (Joker g a a0) Source # mapM :: Monad m => (a0 -> m b) -> Joker g a a0 -> m (Joker g a b) Source # sequence :: Monad m => Joker g a (m a0) -> m (Joker g a a0) Source #
Bitraversable p => Traversable (WrappedBifunctor p a)
Instance details Defined in Data.Bifunctor.Wrapped Methods traverse :: Applicative f => (a0 -> f b) -> WrappedBifunctor p a a0 -> f (WrappedBifunctor p a b) Source # sequenceA :: Applicative f => WrappedBifunctor p a (f a0) -> f (WrappedBifunctor p a a0) Source # mapM :: Monad m => (a0 -> m b) -> WrappedBifunctor p a a0 -> m (WrappedBifunctor p a b) Source # sequence :: Monad m => WrappedBifunctor p a (m a0) -> m (WrappedBifunctor p a a0) Source #
(Traversable f, Bitraversable p) => Traversable (Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Tannen f p a a0 -> f0 (Tannen f p a b) Source # sequenceA :: Applicative f0 => Tannen f p a (f0 a0) -> f0 (Tannen f p a a0) Source # mapM :: Monad m => (a0 -> m b) -> Tannen f p a a0 -> m (Tannen f p a b) Source # sequence :: Monad m => Tannen f p a (m a0) -> m (Tannen f p a a0) Source #
(Bitraversable p, Traversable g) => Traversable (Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Biff p f g a a0 -> f0 (Biff p f g a b) Source # sequenceA :: Applicative f0 => Biff p f g a (f0 a0) -> f0 (Biff p f g a a0) Source # mapM :: Monad m => (a0 -> m b) -> Biff p f g a a0 -> m (Biff p f g a b) Source # sequence :: Monad m => Biff p f g a (m a0) -> m (Biff p f g a a0) Source #

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

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 Source #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

Expand

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

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

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

Instances

Instances details

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d Source # first :: (a -> b) -> Either a c -> Either b c Source # second :: (b -> c) -> Either a b -> Either a c Source #
Bifunctor Arg	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d Source # first :: (a -> b) -> Arg a c -> Arg b c Source # second :: (b -> c) -> Arg a b -> Arg a c Source #
Bifunctor Either
Instance details Defined in Data.Strict.Either Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d Source # first :: (a -> b) -> Either a c -> Either b c Source # second :: (b -> c) -> Either a b -> Either a c Source #
Bifunctor These
Instance details Defined in Data.Strict.These Methods bimap :: (a -> b) -> (c -> d) -> These a c -> These b d Source # first :: (a -> b) -> These a c -> These b c Source # second :: (b -> c) -> These a b -> These a c Source #
Bifunctor Pair
Instance details Defined in Data.Strict.Tuple Methods bimap :: (a -> b) -> (c -> d) -> Pair a c -> Pair b d Source # first :: (a -> b) -> Pair a c -> Pair b c Source # second :: (b -> c) -> Pair a b -> Pair a c Source #
Bifunctor These
Instance details Defined in Data.These Methods bimap :: (a -> b) -> (c -> d) -> These a c -> These b d Source # first :: (a -> b) -> These a c -> These b c Source # second :: (b -> c) -> These a b -> These a c Source #
Bifunctor (,)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) Source # first :: (a -> b) -> (a, c) -> (b, c) Source # second :: (b -> c) -> (a, b) -> (a, c) Source #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d Source # first :: (a -> b) -> Const a c -> Const b c Source # second :: (b -> c) -> Const a b -> Const a c Source #
Functor f => Bifunctor (CofreeF f)
Instance details Defined in Control.Comonad.Trans.Cofree Methods bimap :: (a -> b) -> (c -> d) -> CofreeF f a c -> CofreeF f b d Source # first :: (a -> b) -> CofreeF f a c -> CofreeF f b c Source # second :: (b -> c) -> CofreeF f a b -> CofreeF f a c Source #
Functor f => Bifunctor (FreeF f)
Instance details Defined in Control.Monad.Trans.Free Methods bimap :: (a -> b) -> (c -> d) -> FreeF f a c -> FreeF f b d Source # first :: (a -> b) -> FreeF f a c -> FreeF f b c Source # second :: (b -> c) -> FreeF f a b -> FreeF f a c Source #
Functor f => Bifunctor (AlongsideLeft f) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods bimap :: (a -> b) -> (c -> d) -> AlongsideLeft f a c -> AlongsideLeft f b d Source # first :: (a -> b) -> AlongsideLeft f a c -> AlongsideLeft f b c Source # second :: (b -> c) -> AlongsideLeft f a b -> AlongsideLeft f a c Source #
Functor f => Bifunctor (AlongsideRight f) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods bimap :: (a -> b) -> (c -> d) -> AlongsideRight f a c -> AlongsideRight f b d Source # first :: (a -> b) -> AlongsideRight f a c -> AlongsideRight f b c Source # second :: (b -> c) -> AlongsideRight f a b -> AlongsideRight f a c Source #
Bifunctor (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Tagged Methods bimap :: (a -> b) -> (c -> d) -> Tagged a c -> Tagged b d Source # first :: (a -> b) -> Tagged a c -> Tagged b c Source # second :: (b -> c) -> Tagged a b -> Tagged a c Source #
Bifunctor (Constant :: Type -> Type -> Type)
Instance details Defined in Data.Functor.Constant Methods bimap :: (a -> b) -> (c -> d) -> Constant a c -> Constant b d Source # first :: (a -> b) -> Constant a c -> Constant b c Source # second :: (b -> c) -> Constant a b -> Constant a c Source #
Bifunctor ((,,) x1)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) Source # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) Source # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) Source #
Bifunctor (K1 i :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d Source # first :: (a -> b) -> K1 i a c -> K1 i b c Source # second :: (b -> c) -> K1 i a b -> K1 i a c Source #
Bifunctor ((,,,) x1 x2)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) Source # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) Source # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) Source #
Functor f => Bifunctor (Clown f :: Type -> Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods bimap :: (a -> b) -> (c -> d) -> Clown f a c -> Clown f b d Source # first :: (a -> b) -> Clown f a c -> Clown f b c Source # second :: (b -> c) -> Clown f a b -> Clown f a c Source #
Bifunctor p => Bifunctor (Flip p)
Instance details Defined in Data.Bifunctor.Flip Methods bimap :: (a -> b) -> (c -> d) -> Flip p a c -> Flip p b d Source # first :: (a -> b) -> Flip p a c -> Flip p b c Source # second :: (b -> c) -> Flip p a b -> Flip p a c Source #
Functor g => Bifunctor (Joker g :: Type -> Type -> Type)
Instance details Defined in Data.Bifunctor.Joker Methods bimap :: (a -> b) -> (c -> d) -> Joker g a c -> Joker g b d Source # first :: (a -> b) -> Joker g a c -> Joker g b c Source # second :: (b -> c) -> Joker g a b -> Joker g a c Source #
Bifunctor p => Bifunctor (WrappedBifunctor p)
Instance details Defined in Data.Bifunctor.Wrapped Methods bimap :: (a -> b) -> (c -> d) -> WrappedBifunctor p a c -> WrappedBifunctor p b d Source # first :: (a -> b) -> WrappedBifunctor p a c -> WrappedBifunctor p b c Source # second :: (b -> c) -> WrappedBifunctor p a b -> WrappedBifunctor p a c Source #
Bifunctor ((,,,,) x1 x2 x3)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) Source # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) Source # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) Source #
(Bifunctor f, Bifunctor g) => Bifunctor (Product f g)
Instance details Defined in Data.Bifunctor.Product Methods bimap :: (a -> b) -> (c -> d) -> Product f g a c -> Product f g b d Source # first :: (a -> b) -> Product f g a c -> Product f g b c Source # second :: (b -> c) -> Product f g a b -> Product f g a c Source #
(Bifunctor p, Bifunctor q) => Bifunctor (Sum p q)
Instance details Defined in Data.Bifunctor.Sum Methods bimap :: (a -> b) -> (c -> d) -> Sum p q a c -> Sum p q b d Source # first :: (a -> b) -> Sum p q a c -> Sum p q b c Source # second :: (b -> c) -> Sum p q a b -> Sum p q a c Source #
Bifunctor ((,,,,,) x1 x2 x3 x4)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) Source # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) Source # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) Source #
(Functor f, Bifunctor p) => Bifunctor (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods bimap :: (a -> b) -> (c -> d) -> Tannen f p a c -> Tannen f p b d Source # first :: (a -> b) -> Tannen f p a c -> Tannen f p b c Source # second :: (b -> c) -> Tannen f p a b -> Tannen f p a c Source #
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) Source # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) Source # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) Source #
(Bifunctor p, Functor f, Functor g) => Bifunctor (Biff p f g)
Instance details Defined in Data.Bifunctor.Biff Methods bimap :: (a -> b) -> (c -> d) -> Biff p f g a c -> Biff p f g b d Source # first :: (a -> b) -> Biff p f g a c -> Biff p f g b c Source # second :: (b -> c) -> Biff p f g a b -> Biff p f g a c Source #

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

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 :: (a' -> a) -> (Predicate a -> Predicate a')
  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:

Identity: contramap id = id
Composition: contramap (g . f) = contramap f . contramap g

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' -> a) -> f a -> f a' Source #

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

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

Instances details

Contravariant Comparison	A `Comparison` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to each input of the comparison function.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Comparison a -> Comparison a' Source # (>$) :: b -> Comparison b -> Comparison a Source #
Contravariant Equivalence	Equivalence relations are `Contravariant`, because you can apply the contramapped function to each input to the equivalence relation.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Equivalence a -> Equivalence a' Source # (>$) :: b -> Equivalence b -> Equivalence a Source #
Contravariant Predicate	A `Predicate` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to the input of the predicate. Without newtypes `contramap f` equals precomposing with `f` (= `(. f)`). contramap :: (a' -> a) -> (Predicate a -> Predicate a') contramap f (Predicate g) = Predicate (g . f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Predicate a -> Predicate a' Source # (>$) :: b -> Predicate b -> Predicate a Source #
Contravariant (Op a)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Op a a0 -> Op a a' Source # (>$) :: b -> Op a b -> Op a a0 Source #
Contravariant (Proxy :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Proxy a -> Proxy a' Source # (>$) :: b -> Proxy b -> Proxy a Source #
Contravariant (U1 :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> U1 a -> U1 a' Source # (>$) :: b -> U1 b -> U1 a Source #
Contravariant (V1 :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> V1 a -> V1 a' Source # (>$) :: b -> V1 b -> V1 a Source #
Contravariant f => Contravariant (Indexing f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods contramap :: (a' -> a) -> Indexing f a -> Indexing f a' Source # (>$) :: b -> Indexing f b -> Indexing f a Source #
Contravariant f => Contravariant (Indexing64 f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods contramap :: (a' -> a) -> Indexing64 f a -> Indexing64 f a' Source # (>$) :: b -> Indexing64 f b -> Indexing64 f a Source #
Contravariant m => Contravariant (ListT m)
Instance details Defined in Control.Monad.Trans.List Methods contramap :: (a' -> a) -> ListT m a -> ListT m a' Source # (>$) :: b -> ListT m b -> ListT m a Source #
Contravariant m => Contravariant (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods contramap :: (a' -> a) -> MaybeT m a -> MaybeT m a' Source # (>$) :: b -> MaybeT m b -> MaybeT m a Source #
Contravariant (Const a :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Const a a0 -> Const a a' Source # (>$) :: b -> Const a b -> Const a a0 Source #
Contravariant f => Contravariant (Alt f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Alt f a -> Alt f a' Source # (>$) :: b -> Alt f b -> Alt f a Source #
Contravariant f => Contravariant (Rec1 f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Rec1 f a -> Rec1 f a' Source # (>$) :: b -> Rec1 f b -> Rec1 f a Source #
(Contravariant f, Functor g) => Contravariant (ComposeCF f g)
Instance details Defined in Data.Functor.Contravariant.Compose Methods contramap :: (a' -> a) -> ComposeCF f g a -> ComposeCF f g a' Source # (>$) :: b -> ComposeCF f g b -> ComposeCF f g a Source #
(Functor f, Contravariant g) => Contravariant (ComposeFC f g)
Instance details Defined in Data.Functor.Contravariant.Compose Methods contramap :: (a' -> a) -> ComposeFC f g a -> ComposeFC f g a' Source # (>$) :: b -> ComposeFC f g b -> ComposeFC f g a Source #
Contravariant f => Contravariant (AlongsideLeft f b) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods contramap :: (a' -> a) -> AlongsideLeft f b a -> AlongsideLeft f b a' Source # (>$) :: b0 -> AlongsideLeft f b b0 -> AlongsideLeft f b a Source #
Contravariant f => Contravariant (AlongsideRight f a) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods contramap :: (a' -> a0) -> AlongsideRight f a a0 -> AlongsideRight f a a' Source # (>$) :: b -> AlongsideRight f a b -> AlongsideRight f a a0 Source #
Contravariant (Effect m r) Source #
Instance details Defined in Control.Lens.Internal.Zoom Methods contramap :: (a' -> a) -> Effect m r a -> Effect m r a' Source # (>$) :: b -> Effect m r b -> Effect m r a Source #
Contravariant f => Contravariant (Backwards f)	Derived instance.
Instance details Defined in Control.Applicative.Backwards Methods contramap :: (a' -> a) -> Backwards f a -> Backwards f a' Source # (>$) :: b -> Backwards f b -> Backwards f a Source #
Contravariant m => Contravariant (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods contramap :: (a' -> a) -> ErrorT e m a -> ErrorT e m a' Source # (>$) :: b -> ErrorT e m b -> ErrorT e m a Source #
Contravariant m => Contravariant (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods contramap :: (a' -> a) -> ExceptT e m a -> ExceptT e m a' Source # (>$) :: b -> ExceptT e m b -> ExceptT e m a Source #
Contravariant f => Contravariant (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods contramap :: (a' -> a) -> IdentityT f a -> IdentityT f a' Source # (>$) :: b -> IdentityT f b -> IdentityT f a Source #
Contravariant m => Contravariant (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods contramap :: (a' -> a) -> ReaderT r m a -> ReaderT r m a' Source # (>$) :: b -> ReaderT r m b -> ReaderT r m a Source #
Contravariant m => Contravariant (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods contramap :: (a' -> a) -> StateT s m a -> StateT s m a' Source # (>$) :: b -> StateT s m b -> StateT s m a Source #
Contravariant m => Contravariant (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods contramap :: (a' -> a) -> StateT s m a -> StateT s m a' Source # (>$) :: b -> StateT s m b -> StateT s m a Source #
Contravariant m => Contravariant (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods contramap :: (a' -> a) -> WriterT w m a -> WriterT w m a' Source # (>$) :: b -> WriterT w m b -> WriterT w m a Source #
Contravariant m => Contravariant (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods contramap :: (a' -> a) -> WriterT w m a -> WriterT w m a' Source # (>$) :: b -> WriterT w m b -> WriterT w m a Source #
Contravariant (Constant a :: Type -> Type)
Instance details Defined in Data.Functor.Constant Methods contramap :: (a' -> a0) -> Constant a a0 -> Constant a a' Source # (>$) :: b -> Constant a b -> Constant a a0 Source #
Contravariant f => Contravariant (Reverse f)	Derived instance.
Instance details Defined in Data.Functor.Reverse Methods contramap :: (a' -> a) -> Reverse f a -> Reverse f a' Source # (>$) :: b -> Reverse f b -> Reverse f a Source #
(Contravariant f, Contravariant g) => Contravariant (Product f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Product f g a -> Product f g a' Source # (>$) :: b -> Product f g b -> Product f g a Source #
(Contravariant f, Contravariant g) => Contravariant (Sum f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Sum f g a -> Sum f g a' Source # (>$) :: b -> Sum f g b -> Sum f g a Source #
(Contravariant f, Contravariant g) => Contravariant (f :*: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :: g) a -> (f :: g) a' Source # (>$) :: b -> (f :: g) b -> (f :: g) a Source #
(Contravariant f, Contravariant g) => Contravariant (f :+: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :+: g) a -> (f :+: g) a' Source # (>$) :: b -> (f :+: g) b -> (f :+: g) a Source #
Contravariant (K1 i c :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> K1 i c a -> K1 i c a' Source # (>$) :: b -> K1 i c b -> K1 i c a Source #
Contravariant (Forget r a :: Type -> Type)
Instance details Defined in Data.Profunctor.Types Methods contramap :: (a' -> a0) -> Forget r a a0 -> Forget r a a' Source # (>$) :: b -> Forget r a b -> Forget r a a0 Source #
Contravariant f => Contravariant (Star f a)
Instance details Defined in Data.Profunctor.Types Methods contramap :: (a' -> a0) -> Star f a a0 -> Star f a a' Source # (>$) :: b -> Star f a b -> Star f a a0 Source #
(Functor f, Contravariant g) => Contravariant (Compose f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Compose f g a -> Compose f g a' Source # (>$) :: b -> Compose f g b -> Compose f g a Source #
(Functor f, Contravariant g) => Contravariant (f :.: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :.: g) a -> (f :.: g) a' Source # (>$) :: b -> (f :.: g) b -> (f :.: g) a Source #
Contravariant f => Contravariant (M1 i c f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> M1 i c f a -> M1 i c f a' Source # (>$) :: b -> M1 i c f b -> M1 i c f a Source #
(Profunctor p, Contravariant g) => Contravariant (BazaarT p g a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods contramap :: (a' -> a0) -> BazaarT p g a b a0 -> BazaarT p g a b a' Source # (>$) :: b0 -> BazaarT p g a b b0 -> BazaarT p g a b a0 Source #
(Profunctor p, Contravariant g) => Contravariant (BazaarT1 p g a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods contramap :: (a' -> a0) -> BazaarT1 p g a b a0 -> BazaarT1 p g a b a' Source # (>$) :: b0 -> BazaarT1 p g a b b0 -> BazaarT1 p g a b a0 Source #
(Profunctor p, Contravariant g) => Contravariant (PretextT p g a b) Source #
Instance details Defined in Control.Lens.Internal.Context Methods contramap :: (a' -> a0) -> PretextT p g a b a0 -> PretextT p g a b a' Source # (>$) :: b0 -> PretextT p g a b b0 -> PretextT p g a b a0 Source #
Contravariant f => Contravariant (TakingWhile p f a b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods contramap :: (a' -> a0) -> TakingWhile p f a b a0 -> TakingWhile p f a b a' Source # (>$) :: b0 -> TakingWhile p f a b b0 -> TakingWhile p f a b a0 Source #
Contravariant (EffectRWS w st m s) Source #
Instance details Defined in Control.Lens.Internal.Zoom Methods contramap :: (a' -> a) -> EffectRWS w st m s a -> EffectRWS w st m s a' Source # (>$) :: b -> EffectRWS w st m s b -> EffectRWS w st m s a Source #
Contravariant m => Contravariant (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods contramap :: (a' -> a) -> RWST r w s m a -> RWST r w s m a' Source # (>$) :: b -> RWST r w s m b -> RWST r w s m a Source #
Contravariant m => Contravariant (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods contramap :: (a' -> a) -> RWST r w s m a -> RWST r w s m a' Source # (>$) :: b -> RWST r w s m b -> RWST r w s m a Source #

newtype Identity a Source #

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Constructors

Identity
Fields runIdentity :: a

Instances

Instances details

Representable Identity
Instance details Defined in Data.Functor.Rep Associated Types type Rep Identity Methods tabulate :: (Rep Identity -> a) -> Identity a index :: Identity a -> Rep Identity -> a
MonadFix Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a Source #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m Source # foldMap :: Monoid m => (a -> m) -> Identity a -> m Source # foldMap' :: Monoid m => (a -> m) -> Identity a -> m Source # foldr :: (a -> b -> b) -> b -> Identity a -> b Source # foldr' :: (a -> b -> b) -> b -> Identity a -> b Source # foldl :: (b -> a -> b) -> b -> Identity a -> b Source # foldl' :: (b -> a -> b) -> b -> Identity a -> b Source # foldr1 :: (a -> a -> a) -> Identity a -> a Source # foldl1 :: (a -> a -> a) -> Identity a -> a Source # toList :: Identity a -> [a] Source # null :: Identity a -> Bool Source # length :: Identity a -> Int Source # elem :: Eq a => a -> Identity a -> Bool Source # maximum :: Ord a => Identity a -> a Source # minimum :: Ord a => Identity a -> a Source # sum :: Num a => Identity a -> a Source # product :: Num a => Identity a -> a Source #
Eq1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool Source #
Ord1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Identity a -> Identity b -> Ordering Source #
Read1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Identity a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Identity a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Identity a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Identity a] Source #
Show1 Identity	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS Source #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) Source # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) Source # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) Source # sequence :: Monad m => Identity (m a) -> m (Identity a) Source #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a Source # (<>) :: Identity (a -> b) -> Identity a -> Identity b Source # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source # (>) :: Identity a -> Identity b -> Identity b Source # (<*) :: Identity a -> Identity b -> Identity a Source #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b Source # (<$) :: a -> Identity b -> Identity a Source #
Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b Source # (>>) :: Identity a -> Identity b -> Identity b Source # return :: a -> Identity a Source #
Comonad Identity
Instance details Defined in Control.Comonad Methods extract :: Identity a -> a Source # duplicate :: Identity a -> Identity (Identity a) Source # extend :: (Identity a -> b) -> Identity a -> Identity b Source #
ComonadApply Identity
Instance details Defined in Control.Comonad Methods (<@>) :: Identity (a -> b) -> Identity a -> Identity b Source # (@>) :: Identity a -> Identity b -> Identity b Source # (<@) :: Identity a -> Identity b -> Identity a Source #
NFData1 Identity	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Identity a -> () Source #
Distributive Identity
Instance details Defined in Data.Distributive Methods distribute :: Functor f => f (Identity a) -> Identity (f a) Source # collect :: Functor f => (a -> Identity b) -> f a -> Identity (f b) Source # distributeM :: Monad m => m (Identity a) -> Identity (m a) Source # collectM :: Monad m => (a -> Identity b) -> m a -> Identity (m b) Source #
Hashable1 Identity
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Identity a -> Int Source #
Settable Identity Source #	So you can pass our `Setter` into combinators from other lens libraries.
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Identity a -> a Source # untaintedDot :: Profunctor p => p a (Identity b) -> p a b Source # taintedDot :: Profunctor p => p a b -> p a (Identity b) Source #
Alt Identity	Choose the first option every time. While 'choose the last option' every time is also valid, this instance satisfies more laws. Since: semigroupoids-5.3.6
Instance details Defined in Data.Functor.Alt Methods (<!>) :: Identity a -> Identity a -> Identity a Source # some :: Applicative Identity => Identity a -> Identity [a] Source # many :: Applicative Identity => Identity a -> Identity [a] Source #
Apply Identity
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Identity (a -> b) -> Identity a -> Identity b Source # (.>) :: Identity a -> Identity b -> Identity b Source # (<.) :: Identity a -> Identity b -> Identity a Source # liftF2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source #
Bind Identity
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Identity a -> (a -> Identity b) -> Identity b Source # join :: Identity (Identity a) -> Identity a Source #
Extend Identity
Instance details Defined in Data.Functor.Extend Methods duplicated :: Identity a -> Identity (Identity a) Source # extended :: (Identity a -> b) -> Identity a -> Identity b Source #
Foldable1 Identity
Instance details Defined in Data.Semigroup.Foldable.Class Methods fold1 :: Semigroup m => Identity m -> m Source # foldMap1 :: Semigroup m => (a -> m) -> Identity a -> m Source # toNonEmpty :: Identity a -> NonEmpty a Source #
Traversable1 Identity
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) Source # sequence1 :: Apply f => Identity (f b) -> f (Identity b) Source #
FoldableWithIndex () Identity
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (() -> a -> m) -> Identity a -> m Source # ifoldMap' :: Monoid m => (() -> a -> m) -> Identity a -> m Source # ifoldr :: (() -> a -> b -> b) -> b -> Identity a -> b Source # ifoldl :: (() -> b -> a -> b) -> b -> Identity a -> b Source # ifoldr' :: (() -> a -> b -> b) -> b -> Identity a -> b Source # ifoldl' :: (() -> b -> a -> b) -> b -> Identity a -> b Source #
FunctorWithIndex () Identity
Instance details Defined in WithIndex Methods imap :: (() -> a -> b) -> Identity a -> Identity b Source #
TraversableWithIndex () Identity
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (() -> a -> f b) -> Identity a -> f (Identity b) Source #
Cosieve ReifiedGetter Identity Source #
Instance details Defined in Control.Lens.Reified Methods cosieve :: ReifiedGetter a b -> Identity a -> b Source #
Sieve ReifiedGetter Identity Source #
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedGetter a b -> a -> Identity b Source #
Comonad w => ComonadCofree Identity (CoiterT w)
Instance details Defined in Control.Comonad.Trans.Coiter Methods unwrap :: CoiterT w a -> Identity (CoiterT w a) Source #
Monad m => MonadFree Identity (IterT m)
Instance details Defined in Control.Monad.Trans.Iter Methods wrap :: Identity (IterT m a) -> IterT m a Source #
Unbox a => Vector Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> m (Vector (Identity a)) Source # basicUnsafeThaw :: PrimMonad m => Vector (Identity a) -> m (Mutable Vector (PrimState m) (Identity a)) Source # basicLength :: Vector (Identity a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a) Source # basicUnsafeIndexM :: Monad m => Vector (Identity a) -> Int -> m (Identity a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> Vector (Identity a) -> m () Source # elemseq :: Vector (Identity a) -> Identity a -> b -> b Source #
Unbox a => MVector MVector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Identity a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s (Identity a) -> MVector s (Identity a) Source # basicOverlaps :: MVector s (Identity a) -> MVector s (Identity a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Identity a)) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) (Identity a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Identity a -> m (MVector (PrimState m) (Identity a)) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> m (Identity a) Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> Identity a -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) (Identity a) -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) (Identity a) -> Identity a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Identity a) -> MVector (PrimState m) (Identity a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Identity a) -> MVector (PrimState m) (Identity a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> m (MVector (PrimState m) (Identity a)) Source #
Bits a => Bits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a Source # (.\|.) :: Identity a -> Identity a -> Identity a Source # xor :: Identity a -> Identity a -> Identity a Source # complement :: Identity a -> Identity a Source # shift :: Identity a -> Int -> Identity a Source # rotate :: Identity a -> Int -> Identity a Source # zeroBits :: Identity a Source # bit :: Int -> Identity a Source # setBit :: Identity a -> Int -> Identity a Source # clearBit :: Identity a -> Int -> Identity a Source # complementBit :: Identity a -> Int -> Identity a Source # testBit :: Identity a -> Int -> Bool Source # bitSizeMaybe :: Identity a -> Maybe Int Source # bitSize :: Identity a -> Int Source # isSigned :: Identity a -> Bool Source # shiftL :: Identity a -> Int -> Identity a Source # unsafeShiftL :: Identity a -> Int -> Identity a Source # shiftR :: Identity a -> Int -> Identity a Source # unsafeShiftR :: Identity a -> Int -> Identity a Source # rotateL :: Identity a -> Int -> Identity a Source # rotateR :: Identity a -> Int -> Identity a Source # popCount :: Identity a -> Int Source #
FiniteBits a => FiniteBits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int Source # countLeadingZeros :: Identity a -> Int Source # countTrailingZeros :: Identity a -> Int Source #
Data a => Data (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) Source # toConstr :: Identity a -> Constr Source # dataTypeOf :: Identity a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) Source # gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source #
Storable a => Storable (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int Source # alignment :: Identity a -> Int Source # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) Source # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO (Identity a) Source # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () Source # peek :: Ptr (Identity a) -> IO (Identity a) Source # poke :: Ptr (Identity a) -> Identity a -> IO () Source #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a Source # mappend :: Identity a -> Identity a -> Identity a Source # mconcat :: [Identity a] -> Identity a Source #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a Source # sconcat :: NonEmpty (Identity a) -> Identity a Source # stimes :: Integral b => b -> Identity a -> Identity a Source #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a Source # maxBound :: Identity a Source #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a Source # pred :: Identity a -> Identity a Source # toEnum :: Int -> Identity a Source # fromEnum :: Identity a -> Int Source # enumFrom :: Identity a -> [Identity a] Source # enumFromThen :: Identity a -> Identity a -> [Identity a] Source # enumFromTo :: Identity a -> Identity a -> [Identity a] Source # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] Source #
Floating a => Floating (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a Source # exp :: Identity a -> Identity a Source # log :: Identity a -> Identity a Source # sqrt :: Identity a -> Identity a Source # (**) :: Identity a -> Identity a -> Identity a Source # logBase :: Identity a -> Identity a -> Identity a Source # sin :: Identity a -> Identity a Source # cos :: Identity a -> Identity a Source # tan :: Identity a -> Identity a Source # asin :: Identity a -> Identity a Source # acos :: Identity a -> Identity a Source # atan :: Identity a -> Identity a Source # sinh :: Identity a -> Identity a Source # cosh :: Identity a -> Identity a Source # tanh :: Identity a -> Identity a Source # asinh :: Identity a -> Identity a Source # acosh :: Identity a -> Identity a Source # atanh :: Identity a -> Identity a Source # log1p :: Identity a -> Identity a Source # expm1 :: Identity a -> Identity a Source # log1pexp :: Identity a -> Identity a Source # log1mexp :: Identity a -> Identity a Source #
RealFloat a => RealFloat (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer Source # floatDigits :: Identity a -> Int Source # floatRange :: Identity a -> (Int, Int) Source # decodeFloat :: Identity a -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Identity a Source # exponent :: Identity a -> Int Source # significand :: Identity a -> Identity a Source # scaleFloat :: Int -> Identity a -> Identity a Source # isNaN :: Identity a -> Bool Source # isInfinite :: Identity a -> Bool Source # isDenormalized :: Identity a -> Bool Source # isNegativeZero :: Identity a -> Bool Source # isIEEE :: Identity a -> Bool Source # atan2 :: Identity a -> Identity a -> Identity a Source #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type Source # Methods from :: Identity a -> Rep (Identity a) x Source # to :: Rep (Identity a) x -> Identity a Source #
Ix a => Ix (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] Source # index :: (Identity a, Identity a) -> Identity a -> Int Source # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int Source # inRange :: (Identity a, Identity a) -> Identity a -> Bool Source # rangeSize :: (Identity a, Identity a) -> Int Source # unsafeRangeSize :: (Identity a, Identity a) -> Int Source #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a Source # (-) :: Identity a -> Identity a -> Identity a Source # (*) :: Identity a -> Identity a -> Identity a Source # negate :: Identity a -> Identity a Source # abs :: Identity a -> Identity a Source # signum :: Identity a -> Identity a Source # fromInteger :: Integer -> Identity a Source #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS (Identity a) Source # readList :: ReadS [Identity a] Source # readPrec :: ReadPrec (Identity a) Source # readListPrec :: ReadPrec [Identity a] Source #
Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a Source # recip :: Identity a -> Identity a Source # fromRational :: Rational -> Identity a Source #
Integral a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a Source # rem :: Identity a -> Identity a -> Identity a Source # div :: Identity a -> Identity a -> Identity a Source # mod :: Identity a -> Identity a -> Identity a Source # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) Source # divMod :: Identity a -> Identity a -> (Identity a, Identity a) Source # toInteger :: Identity a -> Integer Source #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational Source #
RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) Source # truncate :: Integral b => Identity a -> b Source # round :: Integral b => Identity a -> b Source # ceiling :: Integral b => Identity a -> b Source # floor :: Integral b => Identity a -> b Source #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS Source # show :: Identity a -> String Source # showList :: [Identity a] -> ShowS Source #
NFData a => NFData (Identity a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Identity a -> () Source #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool Source # (/=) :: Identity a -> Identity a -> Bool Source #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering Source # (<) :: Identity a -> Identity a -> Bool Source # (<=) :: Identity a -> Identity a -> Bool Source # (>) :: Identity a -> Identity a -> Bool Source # (>=) :: Identity a -> Identity a -> Bool Source # max :: Identity a -> Identity a -> Identity a Source # min :: Identity a -> Identity a -> Identity a Source #
Hashable a => Hashable (Identity a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int Source # hash :: Identity a -> Int Source #
Ixed (Identity a) Source #
Instance details Defined in Control.Lens.At Methods ix :: Index (Identity a) -> Traversal' (Identity a) (IxValue (Identity a)) Source #
Wrapped (Identity a) Source #
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Identity a) Source # Methods _Wrapped' :: Iso' (Identity a) (Unwrapped (Identity a)) Source #
Prim a => Prim (Identity a)
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Identity a -> Int# alignment# :: Identity a -> Int# indexByteArray# :: ByteArray# -> Int# -> Identity a readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Identity a #) writeByteArray# :: MutableByteArray# s -> Int# -> Identity a -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Identity a -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Identity a readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Identity a #) writeOffAddr# :: Addr# -> Int# -> Identity a -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Identity a -> State# s -> State# s
Unbox a => Unbox (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Identity
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type Source # Methods from1 :: forall (a :: k). Identity a -> Rep1 Identity a Source # to1 :: forall (a :: k). Rep1 Identity a -> Identity a Source #
t ~ Identity b => Rewrapped (Identity a) t Source #
Instance details Defined in Control.Lens.Wrapped
Each (Identity a) (Identity b) a b Source #	`each` :: `Traversal` (`Identity` a) (`Identity` b) a b
Instance details Defined in Control.Lens.Each Methods each :: Traversal (Identity a) (Identity b) a b Source #
Field1 (Identity a) (Identity b) a b Source #
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (Identity a) (Identity b) a b Source #
Cosieve (->) Identity
Instance details Defined in Data.Profunctor.Sieve Methods cosieve :: (a -> b) -> Identity a -> b Source #
Sieve (->) Identity
Instance details Defined in Data.Profunctor.Sieve Methods sieve :: (a -> b) -> a -> Identity b Source #
type Rep Identity
Instance details Defined in Data.Functor.Rep type Rep Identity = ()
newtype MVector s (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Identity a) = MV_Identity (MVector s a)
type Rep (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep (Identity a) = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Index (Identity a) Source #
Instance details Defined in Control.Lens.At type Index (Identity a) = ()
type IxValue (Identity a) Source #
Instance details Defined in Control.Lens.At type IxValue (Identity a) = a
type Unwrapped (Identity a) Source #
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Identity a) = a
newtype Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Identity a) = V_Identity (Vector a)
type Rep1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep1 Identity = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

newtype Const a (b :: k) Source #

The Const functor.

Constructors

Const
Fields getConst :: a

Instances

Instances details

Generic1 (Const a :: k -> Type)
Instance details Defined in Data.Functor.Const Associated Types type Rep1 (Const a) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0 Source # to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0 Source #
FoldableWithIndex Void (Const e :: Type -> Type)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Void -> a -> m) -> Const e a -> m Source # ifoldMap' :: Monoid m => (Void -> a -> m) -> Const e a -> m Source # ifoldr :: (Void -> a -> b -> b) -> b -> Const e a -> b Source # ifoldl :: (Void -> b -> a -> b) -> b -> Const e a -> b Source # ifoldr' :: (Void -> a -> b -> b) -> b -> Const e a -> b Source # ifoldl' :: (Void -> b -> a -> b) -> b -> Const e a -> b Source #
FunctorWithIndex Void (Const e :: Type -> Type)
Instance details Defined in WithIndex Methods imap :: (Void -> a -> b) -> Const e a -> Const e b Source #
TraversableWithIndex Void (Const e :: Type -> Type)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Void -> a -> f b) -> Const e a -> f (Const e b) Source #
Unbox a => Vector Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> m (Vector (Const a b)) Source # basicUnsafeThaw :: PrimMonad m => Vector (Const a b) -> m (Mutable Vector (PrimState m) (Const a b)) Source # basicLength :: Vector (Const a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) Source # basicUnsafeIndexM :: Monad m => Vector (Const a b) -> Int -> m (Const a b) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> Vector (Const a b) -> m () Source # elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0 Source #
Unbox a => MVector MVector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Const a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b) Source # basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Const a b)) Source # basicInitialize :: PrimMonad m => MVector (PrimState m) (Const a b) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Const a b -> m (MVector (PrimState m) (Const a b)) Source # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (Const a b) Source # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> Const a b -> m () Source # basicClear :: PrimMonad m => MVector (PrimState m) (Const a b) -> m () Source # basicSet :: PrimMonad m => MVector (PrimState m) (Const a b) -> Const a b -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (MVector (PrimState m) (Const a b)) Source #
Bifoldable (Const :: Type -> Type -> Type)	Since: base-4.10.0.0
Instance details Defined in Data.Bifoldable Methods bifold :: Monoid m => Const m m -> m Source # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m Source # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c Source # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c Source #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d Source # first :: (a -> b) -> Const a c -> Const b c Source # second :: (b -> c) -> Const a b -> Const a c Source #
Bitraversable (Const :: Type -> Type -> Type)	Since: base-4.10.0.0
Instance details Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) Source #
Eq2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const a c -> Const b d -> Bool Source #
Ord2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const a c -> Const b d -> Ordering Source #
Read2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) Source # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] Source # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) Source # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] Source #
Show2 (Const :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const a b -> ShowS Source # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const a b] -> ShowS Source #
Biapplicative (Const :: Type -> Type -> Type)
Instance details Defined in Data.Biapplicative Methods bipure :: a -> b -> Const a b Source # (<<>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d Source # biliftA2 :: (a -> b -> c) -> (d -> e -> f) -> Const a d -> Const b e -> Const c f Source # (>>) :: Const a b -> Const c d -> Const c d Source # (<<*) :: Const a b -> Const c d -> Const a b Source #
NFData2 (Const :: Type -> Type -> Type)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Const a b -> () Source #
Hashable2 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Const a b -> Int Source #
Biapply (Const :: Type -> Type -> Type)
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d Source # (.>>) :: Const a b -> Const c d -> Const c d Source # (<<.) :: Const a b -> Const c d -> Const a b Source #
Bifoldable1 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Semigroup.Foldable.Class Methods bifold1 :: Semigroup m => Const m m -> m Source # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Const a b -> m Source #
Bitraversable1 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Semigroup.Traversable.Class Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Const a c -> f (Const b d) Source # bisequence1 :: Apply f => Const (f a) (f b) -> f (Const a b) Source #
Semigroupoid (Const :: Type -> Type -> Type)
Instance details Defined in Data.Semigroupoid Methods o :: forall (j :: k) (k1 :: k) (i :: k). Const j k1 -> Const i j -> Const i k1 Source #
Foldable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 Source # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 Source # foldr :: (a -> b -> b) -> b -> Const m a -> b Source # foldr' :: (a -> b -> b) -> b -> Const m a -> b Source # foldl :: (b -> a -> b) -> b -> Const m a -> b Source # foldl' :: (b -> a -> b) -> b -> Const m a -> b Source # foldr1 :: (a -> a -> a) -> Const m a -> a Source # foldl1 :: (a -> a -> a) -> Const m a -> a Source # toList :: Const m a -> [a] Source # null :: Const m a -> Bool Source # length :: Const m a -> Int Source # elem :: Eq a => a -> Const m a -> Bool Source # maximum :: Ord a => Const m a -> a Source # minimum :: Ord a => Const m a -> a Source # sum :: Num a => Const m a -> a Source # product :: Num a => Const m a -> a Source #
Eq a => Eq1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a0 -> b -> Bool) -> Const a a0 -> Const a b -> Bool Source #
Ord a => Ord1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering Source #
Read a => Read1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) Source # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] Source # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) Source # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] Source #
Show a => Show1 (Const a :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Const a a0 -> ShowS Source # liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Const a a0] -> ShowS Source #
Contravariant (Const a :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Const a a0 -> Const a a' Source # (>$) :: b -> Const a b -> Const a a0 Source #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) Source # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) Source # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) Source # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) Source #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in Data.Functor.Const Methods pure :: a -> Const m a Source # (<>) :: Const m (a -> b) -> Const m a -> Const m b Source # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c Source # (>) :: Const m a -> Const m b -> Const m b Source # (<*) :: Const m a -> Const m b -> Const m a Source #
Functor (Const m :: Type -> Type)	Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b Source # (<$) :: a -> Const m b -> Const m a Source #
NFData a => NFData1 (Const a :: Type -> Type)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> Const a a0 -> () Source #
Hashable a => Hashable1 (Const a :: Type -> Type)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Const a a0 -> Int Source #
Semigroup m => Apply (Const m :: Type -> Type)	A `Const m` is not `Applicative` unless its `m` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Const m (a -> b) -> Const m a -> Const m b Source # (.>) :: Const m a -> Const m b -> Const m b Source # (<.) :: Const m a -> Const m b -> Const m a Source # liftF2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c Source #
ComonadCofree (Const b :: Type -> Type) ((,) b)
Instance details Defined in Control.Comonad.Cofree.Class Methods unwrap :: (b, a) -> Const b (b, a) Source #
Sieve (Forget r :: Type -> Type -> Type) (Const r :: Type -> Type)
Instance details Defined in Data.Profunctor.Sieve Methods sieve :: Forget r a b -> a -> Const r b Source #
Bits a => Bits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b Source # (.\|.) :: Const a b -> Const a b -> Const a b Source # xor :: Const a b -> Const a b -> Const a b Source # complement :: Const a b -> Const a b Source # shift :: Const a b -> Int -> Const a b Source # rotate :: Const a b -> Int -> Const a b Source # zeroBits :: Const a b Source # bit :: Int -> Const a b Source # setBit :: Const a b -> Int -> Const a b Source # clearBit :: Const a b -> Int -> Const a b Source # complementBit :: Const a b -> Int -> Const a b Source # testBit :: Const a b -> Int -> Bool Source # bitSizeMaybe :: Const a b -> Maybe Int Source # bitSize :: Const a b -> Int Source # isSigned :: Const a b -> Bool Source # shiftL :: Const a b -> Int -> Const a b Source # unsafeShiftL :: Const a b -> Int -> Const a b Source # shiftR :: Const a b -> Int -> Const a b Source # unsafeShiftR :: Const a b -> Int -> Const a b Source # rotateL :: Const a b -> Int -> Const a b Source # rotateR :: Const a b -> Int -> Const a b Source # popCount :: Const a b -> Int Source #
FiniteBits a => FiniteBits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int Source # countLeadingZeros :: Const a b -> Int Source # countTrailingZeros :: Const a b -> Int Source #
(Typeable k, Data a, Typeable b) => Data (Const a b)	Since: base-4.10.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) Source # toConstr :: Const a b -> Constr Source # dataTypeOf :: Const a b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) Source #
Storable a => Storable (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int Source # alignment :: Const a b -> Int Source # peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) Source # pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () Source # peekByteOff :: Ptr b0 -> Int -> IO (Const a b) Source # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () Source # peek :: Ptr (Const a b) -> IO (Const a b) Source # poke :: Ptr (Const a b) -> Const a b -> IO () Source #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b Source # mappend :: Const a b -> Const a b -> Const a b Source # mconcat :: [Const a b] -> Const a b Source #
Semigroup a => Semigroup (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b Source # sconcat :: NonEmpty (Const a b) -> Const a b Source # stimes :: Integral b0 => b0 -> Const a b -> Const a b Source #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b Source # maxBound :: Const a b Source #
Enum a => Enum (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b Source # pred :: Const a b -> Const a b Source # toEnum :: Int -> Const a b Source # fromEnum :: Const a b -> Int Source # enumFrom :: Const a b -> [Const a b] Source # enumFromThen :: Const a b -> Const a b -> [Const a b] Source # enumFromTo :: Const a b -> Const a b -> [Const a b] Source # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] Source #
Floating a => Floating (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods pi :: Const a b Source # exp :: Const a b -> Const a b Source # log :: Const a b -> Const a b Source # sqrt :: Const a b -> Const a b Source # (**) :: Const a b -> Const a b -> Const a b Source # logBase :: Const a b -> Const a b -> Const a b Source # sin :: Const a b -> Const a b Source # cos :: Const a b -> Const a b Source # tan :: Const a b -> Const a b Source # asin :: Const a b -> Const a b Source # acos :: Const a b -> Const a b Source # atan :: Const a b -> Const a b Source # sinh :: Const a b -> Const a b Source # cosh :: Const a b -> Const a b Source # tanh :: Const a b -> Const a b Source # asinh :: Const a b -> Const a b Source # acosh :: Const a b -> Const a b Source # atanh :: Const a b -> Const a b Source # log1p :: Const a b -> Const a b Source # expm1 :: Const a b -> Const a b Source # log1pexp :: Const a b -> Const a b Source # log1mexp :: Const a b -> Const a b Source #
RealFloat a => RealFloat (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer Source # floatDigits :: Const a b -> Int Source # floatRange :: Const a b -> (Int, Int) Source # decodeFloat :: Const a b -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Const a b Source # exponent :: Const a b -> Int Source # significand :: Const a b -> Const a b Source # scaleFloat :: Int -> Const a b -> Const a b Source # isNaN :: Const a b -> Bool Source # isInfinite :: Const a b -> Bool Source # isDenormalized :: Const a b -> Bool Source # isNegativeZero :: Const a b -> Bool Source # isIEEE :: Const a b -> Bool Source # atan2 :: Const a b -> Const a b -> Const a b Source #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type Source # Methods from :: Const a b -> Rep (Const a b) x Source # to :: Rep (Const a b) x -> Const a b Source #
Ix a => Ix (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] Source # index :: (Const a b, Const a b) -> Const a b -> Int Source # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int Source # inRange :: (Const a b, Const a b) -> Const a b -> Bool Source # rangeSize :: (Const a b, Const a b) -> Int Source # unsafeRangeSize :: (Const a b, Const a b) -> Int Source #
Num a => Num (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b Source # (-) :: Const a b -> Const a b -> Const a b Source # (*) :: Const a b -> Const a b -> Const a b Source # negate :: Const a b -> Const a b Source # abs :: Const a b -> Const a b Source # signum :: Const a b -> Const a b Source # fromInteger :: Integer -> Const a b Source #
Read a => Read (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods readsPrec :: Int -> ReadS (Const a b) Source # readList :: ReadS [Const a b] Source # readPrec :: ReadPrec (Const a b) Source # readListPrec :: ReadPrec [Const a b] Source #
Fractional a => Fractional (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b Source # recip :: Const a b -> Const a b Source # fromRational :: Rational -> Const a b Source #
Integral a => Integral (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b Source # rem :: Const a b -> Const a b -> Const a b Source # div :: Const a b -> Const a b -> Const a b Source # mod :: Const a b -> Const a b -> Const a b Source # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) Source # divMod :: Const a b -> Const a b -> (Const a b, Const a b) Source # toInteger :: Const a b -> Integer Source #
Real a => Real (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational Source #
RealFrac a => RealFrac (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) Source # truncate :: Integral b0 => Const a b -> b0 Source # round :: Integral b0 => Const a b -> b0 Source # ceiling :: Integral b0 => Const a b -> b0 Source # floor :: Integral b0 => Const a b -> b0 Source #
Show a => Show (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS Source # show :: Const a b -> String Source # showList :: [Const a b] -> ShowS Source #
NFData a => NFData (Const a b)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Const a b -> () Source #
Eq a => Eq (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool Source # (/=) :: Const a b -> Const a b -> Bool Source #
Ord a => Ord (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering Source # (<) :: Const a b -> Const a b -> Bool Source # (<=) :: Const a b -> Const a b -> Bool Source # (>) :: Const a b -> Const a b -> Bool Source # (>=) :: Const a b -> Const a b -> Bool Source # max :: Const a b -> Const a b -> Const a b Source # min :: Const a b -> Const a b -> Const a b Source #
Hashable a => Hashable (Const a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int Source # hash :: Const a b -> Int Source #
Wrapped (Const a x) Source #
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Const a x) Source # Methods _Wrapped' :: Iso' (Const a x) (Unwrapped (Const a x)) Source #
Prim a => Prim (Const a b)
Instance details Defined in Data.Primitive.Types Methods sizeOf# :: Const a b -> Int# alignment# :: Const a b -> Int# indexByteArray# :: ByteArray# -> Int# -> Const a b readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Const a b #) writeByteArray# :: MutableByteArray# s -> Int# -> Const a b -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Const a b -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Const a b readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Const a b #) writeOffAddr# :: Addr# -> Int# -> Const a b -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Const a b -> State# s -> State# s
Unbox a => Unbox (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base
t ~ Const a' x' => Rewrapped (Const a x) t Source #
Instance details Defined in Control.Lens.Wrapped
type Rep1 (Const a :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep1 (Const a :: k -> Type) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
newtype MVector s (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Const a b) = MV_Const (MVector s a)
type Rep (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep (Const a b) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Unwrapped (Const a x) Source #
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Const a x) = a
newtype Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Const a b) = V_Const (Vector a)

data (a :: k) :~: (b :: k) where infix 4 Source #

Propositional equality. If a :~: b is inhabited by some terminating value, then the type a is the same as the type b. To use this equality in practice, pattern-match on the a :~: b to get out the Refl constructor; in the body of the pattern-match, the compiler knows that a ~ b.

Since: base-4.7.0.0

Constructors

Refl :: forall {k} (a :: k). a :~: a

Instances

Instances details

Category ((:~:) :: k -> k -> Type)	Since: base-4.7.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). a :~: a Source # (.) :: forall (b :: k0) (c :: k0) (a :: k0). (b :~: c) -> (a :~: b) -> a :~: c Source #
Semigroupoid ((:~:) :: k -> k -> Type)
Instance details Defined in Data.Semigroupoid Methods o :: forall (j :: k0) (k1 :: k0) (i :: k0). (j :~: k1) -> (i :~: j) -> i :~: k1 Source #
TestCoercion ((:~:) a :: k -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods testCoercion :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe (Coercion a0 b) Source #
TestEquality ((:~:) a :: k -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b) Source #
NFData2 ((:~:) :: Type -> Type -> Type)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> (a :~: b) -> () Source #
NFData1 ((:~:) a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> (a :~: a0) -> () Source #
(a ~ b, Data a) => Data (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~: b) -> c (a :~: b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~: b) Source # toConstr :: (a :~: b) -> Constr Source # dataTypeOf :: (a :~: b) -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~: b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~: b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~: b) -> a :~: b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (a :~: b) -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~: b) -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) Source #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b Source # maxBound :: a :~: b Source #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b Source # pred :: (a :~: b) -> a :~: b Source # toEnum :: Int -> a :~: b Source # fromEnum :: (a :~: b) -> Int Source # enumFrom :: (a :~: b) -> [a :~: b] Source # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] Source # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] Source # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] Source #
a ~ b => Read (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods readsPrec :: Int -> ReadS (a :~: b) Source # readList :: ReadS [a :~: b] Source # readPrec :: ReadPrec (a :~: b) Source # readListPrec :: ReadPrec [a :~: b] Source #
Show (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~: b) -> ShowS Source # show :: (a :~: b) -> String Source # showList :: [a :~: b] -> ShowS Source #
NFData (a :~: b)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a :~: b) -> () Source #
Eq (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~: b) -> (a :~: b) -> Bool Source # (/=) :: (a :~: b) -> (a :~: b) -> Bool Source #
Ord (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods compare :: (a :~: b) -> (a :~: b) -> Ordering Source # (<) :: (a :~: b) -> (a :~: b) -> Bool Source # (<=) :: (a :~: b) -> (a :~: b) -> Bool Source # (>) :: (a :~: b) -> (a :~: b) -> Bool Source # (>=) :: (a :~: b) -> (a :~: b) -> Bool Source # max :: (a :~: b) -> (a :~: b) -> a :~: b Source # min :: (a :~: b) -> (a :~: b) -> a :~: b Source #

itoList :: FoldableWithIndex i f => f a -> [(i, a)] Source #

Extract the key-value pairs from a structure.

When you don't need access to the indices in the result, then toList is more flexible in what it accepts.

toList ≡ map snd . itoList

ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b Source #

Monadic fold over the elements of a structure with an index, associating to the left.

When you don't need access to the index then foldlM is more flexible in what it accepts.

foldlM ≡ ifoldlM . const

ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b Source #

Monadic fold right over the elements of a structure with an index.

When you don't need access to the index then foldrM is more flexible in what it accepts.

foldrM ≡ ifoldrM . const

ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a) Source #

Searches a container with a predicate that is also supplied the index, returning the left-most element of the structure matching the predicate, or Nothing if there is no such element.

When you don't need access to the index then find is more flexible in what it accepts.

find ≡ ifind . const

iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b] Source #

Concatenate the results of a function of the elements of an indexed container with access to the index.

When you don't need access to the index then concatMap is more flexible in what it accepts.

concatMap ≡ iconcatMap . const
iconcatMap ≡ ifoldMap

iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m () Source #

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results (with the arguments flipped).

iforM_ ≡ flip imapM_

When you don't need access to the index then forM_ is more flexible in what it accepts.

forM_ a ≡ iforM a . const

imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m () Source #

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results.

When you don't need access to the index then mapMOf_ is more flexible in what it accepts.

mapM_ ≡ imapM . const

ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f () Source #

Traverse elements with access to the index i, discarding the results (with the arguments flipped).

ifor_ ≡ flip itraverse_

When you don't need access to the index then for_ is more flexible in what it accepts.

for_ a ≡ ifor_ a . const

itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f () Source #

Traverse elements with access to the index i, discarding the results.

When you don't need access to the index then traverse_ is more flexible in what it accepts.

traverse_ l = itraverse . const

none :: Foldable f => (a -> Bool) -> f a -> Bool Source #

Determines whether no elements of the structure satisfy the predicate.

none f ≡ not . any f

inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool Source #

Return whether or not none of the elements in a container satisfy a predicate, with access to the index i.

When you don't need access to the index then none is more flexible in what it accepts.

none ≡ inone . const
inone f ≡ not . iany f

iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool Source #

Return whether or not all elements in a container satisfy a predicate, with access to the index i.

When you don't need access to the index then all is more flexible in what it accepts.

all ≡ iall . const

iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool Source #

Return whether or not any element in a container satisfies a predicate, with access to the index i.

When you don't need access to the index then any is more flexible in what it accepts.

any ≡ iany . const

imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b) Source #

Generalizes mapAccumL to add access to the index.

imapAccumL accumulates state from left to right.

mapAccumL ≡ imapAccumL . const

imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b) Source #

Generalizes mapAccumR to add access to the index.

imapAccumR accumulates state from right to left.

mapAccumR ≡ imapAccumR . const

iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b) Source #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access its position (and the arguments flipped).

forM a ≡ iforM a . const
iforM ≡ flip imapM

imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b) Source #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access the index.

When you don't need access to the index mapM is more liberal in what it can accept.

mapM ≡ imapM . const

ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b) Source #

Traverse with an index (and the arguments flipped).

for a ≡ ifor a . const
ifor ≡ flip itraverse

class Functor f => FunctorWithIndex i (f :: Type -> Type) | f -> i where Source #

A Functor with an additional index.

Instances must satisfy a modified form of the Functor laws:

imap f . imap g ≡ imap (\i -> f i . g i)
imap (\_ a -> a) ≡ id

Minimal complete definition

Nothing

Methods

imap :: (i -> a -> b) -> f a -> f b Source #

Map with access to the index.

Instances

Instances details

FunctorWithIndex () Identity
Instance details Defined in WithIndex Methods imap :: (() -> a -> b) -> Identity a -> Identity b Source #
FunctorWithIndex () Par1
Instance details Defined in WithIndex Methods imap :: (() -> a -> b) -> Par1 a -> Par1 b Source #
FunctorWithIndex () Maybe
Instance details Defined in WithIndex Methods imap :: (() -> a -> b) -> Maybe a -> Maybe b Source #
FunctorWithIndex Int ZipList	Same instance as for `[]`.
Instance details Defined in WithIndex Methods imap :: (Int -> a -> b) -> ZipList a -> ZipList b Source #
FunctorWithIndex Int NonEmpty
Instance details Defined in WithIndex Methods imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b Source #
FunctorWithIndex Int IntMap
Instance details Defined in WithIndex Methods imap :: (Int -> a -> b) -> IntMap a -> IntMap b Source #
FunctorWithIndex Int Seq	The position in the `Seq` is available as the index.
Instance details Defined in WithIndex Methods imap :: (Int -> a -> b) -> Seq a -> Seq b Source #
FunctorWithIndex Int Deque Source #
Instance details Defined in Control.Lens.Internal.Deque Methods imap :: (Int -> a -> b) -> Deque a -> Deque b Source #
FunctorWithIndex Int []	The position in the list is available as the index.
Instance details Defined in WithIndex Methods imap :: (Int -> a -> b) -> [a] -> [b] Source #
FunctorWithIndex Void (Proxy :: Type -> Type)
Instance details Defined in WithIndex Methods imap :: (Void -> a -> b) -> Proxy a -> Proxy b Source #
FunctorWithIndex Void (U1 :: Type -> Type)
Instance details Defined in WithIndex Methods imap :: (Void -> a -> b) -> U1 a -> U1 b Source #
FunctorWithIndex Void (V1 :: Type -> Type)
Instance details Defined in WithIndex Methods imap :: (Void -> a -> b) -> V1 a -> V1 b Source #
Ix i => FunctorWithIndex i (Array i)
Instance details Defined in WithIndex Methods imap :: (i -> a -> b) -> Array i a -> Array i b Source #
FunctorWithIndex i (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods imap :: (i -> a -> b) -> Level i a -> Level i b Source #
FunctorWithIndex k (Map k)
Instance details Defined in WithIndex Methods imap :: (k -> a -> b) -> Map k a -> Map k b Source #
FunctorWithIndex k ((,) k)
Instance details Defined in WithIndex Methods imap :: (k -> a -> b) -> (k, a) -> (k, b) Source #
FunctorWithIndex Void (Const e :: Type -> Type)
Instance details Defined in WithIndex Methods imap :: (Void -> a -> b) -> Const e a -> Const e b Source #
FunctorWithIndex Void (Constant e :: Type -> Type)
Instance details Defined in WithIndex Methods imap :: (Void -> a -> b) -> Constant e a -> Constant e b Source #
FunctorWithIndex i f => FunctorWithIndex i (Rec1 f)
Instance details Defined in WithIndex Methods imap :: (i -> a -> b) -> Rec1 f a -> Rec1 f b Source #
FunctorWithIndex i f => FunctorWithIndex i (Backwards f)
Instance details Defined in WithIndex Methods imap :: (i -> a -> b) -> Backwards f a -> Backwards f b Source #
FunctorWithIndex i m => FunctorWithIndex i (IdentityT m)
Instance details Defined in WithIndex Methods imap :: (i -> a -> b) -> IdentityT m a -> IdentityT m b Source #
FunctorWithIndex i f => FunctorWithIndex i (Reverse f)
Instance details Defined in WithIndex Methods imap :: (i -> a -> b) -> Reverse f a -> Reverse f b Source #
FunctorWithIndex Void (K1 i c :: Type -> Type)
Instance details Defined in WithIndex Methods imap :: (Void -> a -> b) -> K1 i c a -> K1 i c b Source #
FunctorWithIndex i (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods imap :: (i -> a -> b0) -> Magma i t b a -> Magma i t b b0 Source #
FunctorWithIndex r ((->) r)
Instance details Defined in WithIndex Methods imap :: (r -> a -> b) -> (r -> a) -> r -> b Source #
FunctorWithIndex [Int] Tree
Instance details Defined in WithIndex Methods imap :: ([Int] -> a -> b) -> Tree a -> Tree b Source #
FunctorWithIndex i f => FunctorWithIndex [i] (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods imap :: ([i] -> a -> b) -> Cofree f a -> Cofree f b Source #
FunctorWithIndex i f => FunctorWithIndex [i] (Free f)
Instance details Defined in Control.Monad.Free Methods imap :: ([i] -> a -> b) -> Free f a -> Free f b Source #
FunctorWithIndex i m => FunctorWithIndex (e, i) (ReaderT e m)
Instance details Defined in WithIndex Methods imap :: ((e, i) -> a -> b) -> ReaderT e m a -> ReaderT e m b Source #
FunctorWithIndex i w => FunctorWithIndex (s, i) (TracedT s w)
Instance details Defined in Control.Comonad.Trans.Traced Methods imap :: ((s, i) -> a -> b) -> TracedT s w a -> TracedT s w b Source #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Product f g)
Instance details Defined in WithIndex Methods imap :: (Either i j -> a -> b) -> Product f g a -> Product f g b Source #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Sum f g)
Instance details Defined in WithIndex Methods imap :: (Either i j -> a -> b) -> Sum f g a -> Sum f g b Source #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :*: g)
Instance details Defined in WithIndex Methods imap :: (Either i j -> a -> b) -> (f :: g) a -> (f :: g) b Source #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :+: g)
Instance details Defined in WithIndex Methods imap :: (Either i j -> a -> b) -> (f :+: g) a -> (f :+: g) b Source #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (Compose f g)
Instance details Defined in WithIndex Methods imap :: ((i, j) -> a -> b) -> Compose f g a -> Compose f g b Source #
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (f :.: g)
Instance details Defined in WithIndex Methods imap :: ((i, j) -> a -> b) -> (f :.: g) a -> (f :.: g) b Source #

class Foldable f => FoldableWithIndex i (f :: Type -> Type) | f -> i where Source #

A container that supports folding with an additional index.

Minimal complete definition

Nothing

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m Source #

Fold a container by mapping value to an arbitrary Monoid with access to the index i.

When you don't need access to the index then foldMap is more flexible in what it accepts.

foldMap ≡ ifoldMap . const

ifoldMap' :: Monoid m => (i -> a -> m) -> f a -> m Source #

A variant of ifoldMap that is strict in the accumulator.

When you don't need access to the index then foldMap' is more flexible in what it accepts.

foldMap' ≡ ifoldMap' . const

ifoldr :: (i -> a -> b -> b) -> b -> f a -> b Source #

Right-associative fold of an indexed container with access to the index i.

When you don't need access to the index then foldr is more flexible in what it accepts.

foldr ≡ ifoldr . const

ifoldl :: (i -> b -> a -> b) -> b -> f a -> b Source #

Left-associative fold of an indexed container with access to the index i.

When you don't need access to the index then foldl is more flexible in what it accepts.

foldl ≡ ifoldl . const

ifoldr' :: (i -> a -> b -> b) -> b -> f a -> b Source #

Strictly fold right over the elements of a structure with access to the index i.

When you don't need access to the index then foldr' is more flexible in what it accepts.

foldr' ≡ ifoldr' . const

ifoldl' :: (i -> b -> a -> b) -> b -> f a -> b Source #

Fold over the elements of a structure with an index, associating to the left, but strictly.

When you don't need access to the index then foldlOf' is more flexible in what it accepts.

foldl' l ≡ ifoldl' l . const

Instances

Instances details

FoldableWithIndex () Identity
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (() -> a -> m) -> Identity a -> m Source # ifoldMap' :: Monoid m => (() -> a -> m) -> Identity a -> m Source # ifoldr :: (() -> a -> b -> b) -> b -> Identity a -> b Source # ifoldl :: (() -> b -> a -> b) -> b -> Identity a -> b Source # ifoldr' :: (() -> a -> b -> b) -> b -> Identity a -> b Source # ifoldl' :: (() -> b -> a -> b) -> b -> Identity a -> b Source #
FoldableWithIndex () Par1
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (() -> a -> m) -> Par1 a -> m Source # ifoldMap' :: Monoid m => (() -> a -> m) -> Par1 a -> m Source # ifoldr :: (() -> a -> b -> b) -> b -> Par1 a -> b Source # ifoldl :: (() -> b -> a -> b) -> b -> Par1 a -> b Source # ifoldr' :: (() -> a -> b -> b) -> b -> Par1 a -> b Source # ifoldl' :: (() -> b -> a -> b) -> b -> Par1 a -> b Source #
FoldableWithIndex () Maybe
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (() -> a -> m) -> Maybe a -> m Source # ifoldMap' :: Monoid m => (() -> a -> m) -> Maybe a -> m Source # ifoldr :: (() -> a -> b -> b) -> b -> Maybe a -> b Source # ifoldl :: (() -> b -> a -> b) -> b -> Maybe a -> b Source # ifoldr' :: (() -> a -> b -> b) -> b -> Maybe a -> b Source # ifoldl' :: (() -> b -> a -> b) -> b -> Maybe a -> b Source #
FoldableWithIndex Int ZipList
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Int -> a -> m) -> ZipList a -> m Source # ifoldMap' :: Monoid m => (Int -> a -> m) -> ZipList a -> m Source # ifoldr :: (Int -> a -> b -> b) -> b -> ZipList a -> b Source # ifoldl :: (Int -> b -> a -> b) -> b -> ZipList a -> b Source # ifoldr' :: (Int -> a -> b -> b) -> b -> ZipList a -> b Source # ifoldl' :: (Int -> b -> a -> b) -> b -> ZipList a -> b Source #
FoldableWithIndex Int NonEmpty
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m Source # ifoldMap' :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m Source # ifoldr :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b Source # ifoldl :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b Source # ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b Source # ifoldl' :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b Source #
FoldableWithIndex Int IntMap
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m Source # ifoldMap' :: Monoid m => (Int -> a -> m) -> IntMap a -> m Source # ifoldr :: (Int -> a -> b -> b) -> b -> IntMap a -> b Source # ifoldl :: (Int -> b -> a -> b) -> b -> IntMap a -> b Source # ifoldr' :: (Int -> a -> b -> b) -> b -> IntMap a -> b Source # ifoldl' :: (Int -> b -> a -> b) -> b -> IntMap a -> b Source #
FoldableWithIndex Int Seq
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m Source # ifoldMap' :: Monoid m => (Int -> a -> m) -> Seq a -> m Source # ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b Source # ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b Source # ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b Source # ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b Source #
FoldableWithIndex Int Deque Source #
Instance details Defined in Control.Lens.Internal.Deque Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Deque a -> m Source # ifoldMap' :: Monoid m => (Int -> a -> m) -> Deque a -> m Source # ifoldr :: (Int -> a -> b -> b) -> b -> Deque a -> b Source # ifoldl :: (Int -> b -> a -> b) -> b -> Deque a -> b Source # ifoldr' :: (Int -> a -> b -> b) -> b -> Deque a -> b Source # ifoldl' :: (Int -> b -> a -> b) -> b -> Deque a -> b Source #
FoldableWithIndex Int []
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m Source # ifoldMap' :: Monoid m => (Int -> a -> m) -> [a] -> m Source # ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b Source # ifoldl :: (Int -> b -> a -> b) -> b -> [a] -> b Source # ifoldr' :: (Int -> a -> b -> b) -> b -> [a] -> b Source # ifoldl' :: (Int -> b -> a -> b) -> b -> [a] -> b Source #
FoldableWithIndex Void (Proxy :: Type -> Type)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Void -> a -> m) -> Proxy a -> m Source # ifoldMap' :: Monoid m => (Void -> a -> m) -> Proxy a -> m Source # ifoldr :: (Void -> a -> b -> b) -> b -> Proxy a -> b Source # ifoldl :: (Void -> b -> a -> b) -> b -> Proxy a -> b Source # ifoldr' :: (Void -> a -> b -> b) -> b -> Proxy a -> b Source # ifoldl' :: (Void -> b -> a -> b) -> b -> Proxy a -> b Source #
FoldableWithIndex Void (U1 :: Type -> Type)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Void -> a -> m) -> U1 a -> m Source # ifoldMap' :: Monoid m => (Void -> a -> m) -> U1 a -> m Source # ifoldr :: (Void -> a -> b -> b) -> b -> U1 a -> b Source # ifoldl :: (Void -> b -> a -> b) -> b -> U1 a -> b Source # ifoldr' :: (Void -> a -> b -> b) -> b -> U1 a -> b Source # ifoldl' :: (Void -> b -> a -> b) -> b -> U1 a -> b Source #
FoldableWithIndex Void (V1 :: Type -> Type)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Void -> a -> m) -> V1 a -> m Source # ifoldMap' :: Monoid m => (Void -> a -> m) -> V1 a -> m Source # ifoldr :: (Void -> a -> b -> b) -> b -> V1 a -> b Source # ifoldl :: (Void -> b -> a -> b) -> b -> V1 a -> b Source # ifoldr' :: (Void -> a -> b -> b) -> b -> V1 a -> b Source # ifoldl' :: (Void -> b -> a -> b) -> b -> V1 a -> b Source #
Ix i => FoldableWithIndex i (Array i)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (i -> a -> m) -> Array i a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Array i a -> m Source # ifoldr :: (i -> a -> b -> b) -> b -> Array i a -> b Source # ifoldl :: (i -> b -> a -> b) -> b -> Array i a -> b Source # ifoldr' :: (i -> a -> b -> b) -> b -> Array i a -> b Source # ifoldl' :: (i -> b -> a -> b) -> b -> Array i a -> b Source #
FoldableWithIndex i (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods ifoldMap :: Monoid m => (i -> a -> m) -> Level i a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Level i a -> m Source # ifoldr :: (i -> a -> b -> b) -> b -> Level i a -> b Source # ifoldl :: (i -> b -> a -> b) -> b -> Level i a -> b Source # ifoldr' :: (i -> a -> b -> b) -> b -> Level i a -> b Source # ifoldl' :: (i -> b -> a -> b) -> b -> Level i a -> b Source #
FoldableWithIndex k (Map k)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (k -> a -> m) -> Map k a -> m Source # ifoldMap' :: Monoid m => (k -> a -> m) -> Map k a -> m Source # ifoldr :: (k -> a -> b -> b) -> b -> Map k a -> b Source # ifoldl :: (k -> b -> a -> b) -> b -> Map k a -> b Source # ifoldr' :: (k -> a -> b -> b) -> b -> Map k a -> b Source # ifoldl' :: (k -> b -> a -> b) -> b -> Map k a -> b Source #
FoldableWithIndex k ((,) k)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (k -> a -> m) -> (k, a) -> m Source # ifoldMap' :: Monoid m => (k -> a -> m) -> (k, a) -> m Source # ifoldr :: (k -> a -> b -> b) -> b -> (k, a) -> b Source # ifoldl :: (k -> b -> a -> b) -> b -> (k, a) -> b Source # ifoldr' :: (k -> a -> b -> b) -> b -> (k, a) -> b Source # ifoldl' :: (k -> b -> a -> b) -> b -> (k, a) -> b Source #
FoldableWithIndex Void (Const e :: Type -> Type)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Void -> a -> m) -> Const e a -> m Source # ifoldMap' :: Monoid m => (Void -> a -> m) -> Const e a -> m Source # ifoldr :: (Void -> a -> b -> b) -> b -> Const e a -> b Source # ifoldl :: (Void -> b -> a -> b) -> b -> Const e a -> b Source # ifoldr' :: (Void -> a -> b -> b) -> b -> Const e a -> b Source # ifoldl' :: (Void -> b -> a -> b) -> b -> Const e a -> b Source #
FoldableWithIndex Void (Constant e :: Type -> Type)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Void -> a -> m) -> Constant e a -> m Source # ifoldMap' :: Monoid m => (Void -> a -> m) -> Constant e a -> m Source # ifoldr :: (Void -> a -> b -> b) -> b -> Constant e a -> b Source # ifoldl :: (Void -> b -> a -> b) -> b -> Constant e a -> b Source # ifoldr' :: (Void -> a -> b -> b) -> b -> Constant e a -> b Source # ifoldl' :: (Void -> b -> a -> b) -> b -> Constant e a -> b Source #
FoldableWithIndex i f => FoldableWithIndex i (Rec1 f)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (i -> a -> m) -> Rec1 f a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Rec1 f a -> m Source # ifoldr :: (i -> a -> b -> b) -> b -> Rec1 f a -> b Source # ifoldl :: (i -> b -> a -> b) -> b -> Rec1 f a -> b Source # ifoldr' :: (i -> a -> b -> b) -> b -> Rec1 f a -> b Source # ifoldl' :: (i -> b -> a -> b) -> b -> Rec1 f a -> b Source #
FoldableWithIndex i f => FoldableWithIndex i (Backwards f)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (i -> a -> m) -> Backwards f a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Backwards f a -> m Source # ifoldr :: (i -> a -> b -> b) -> b -> Backwards f a -> b Source # ifoldl :: (i -> b -> a -> b) -> b -> Backwards f a -> b Source # ifoldr' :: (i -> a -> b -> b) -> b -> Backwards f a -> b Source # ifoldl' :: (i -> b -> a -> b) -> b -> Backwards f a -> b Source #
FoldableWithIndex i m => FoldableWithIndex i (IdentityT m)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m0 => (i -> a -> m0) -> IdentityT m a -> m0 Source # ifoldMap' :: Monoid m0 => (i -> a -> m0) -> IdentityT m a -> m0 Source # ifoldr :: (i -> a -> b -> b) -> b -> IdentityT m a -> b Source # ifoldl :: (i -> b -> a -> b) -> b -> IdentityT m a -> b Source # ifoldr' :: (i -> a -> b -> b) -> b -> IdentityT m a -> b Source # ifoldl' :: (i -> b -> a -> b) -> b -> IdentityT m a -> b Source #
FoldableWithIndex i f => FoldableWithIndex i (Reverse f)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (i -> a -> m) -> Reverse f a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Reverse f a -> m Source # ifoldr :: (i -> a -> b -> b) -> b -> Reverse f a -> b Source # ifoldl :: (i -> b -> a -> b) -> b -> Reverse f a -> b Source # ifoldr' :: (i -> a -> b -> b) -> b -> Reverse f a -> b Source # ifoldl' :: (i -> b -> a -> b) -> b -> Reverse f a -> b Source #
FoldableWithIndex Void (K1 i c :: Type -> Type)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Void -> a -> m) -> K1 i c a -> m Source # ifoldMap' :: Monoid m => (Void -> a -> m) -> K1 i c a -> m Source # ifoldr :: (Void -> a -> b -> b) -> b -> K1 i c a -> b Source # ifoldl :: (Void -> b -> a -> b) -> b -> K1 i c a -> b Source # ifoldr' :: (Void -> a -> b -> b) -> b -> K1 i c a -> b Source # ifoldl' :: (Void -> b -> a -> b) -> b -> K1 i c a -> b Source #
FoldableWithIndex i (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods ifoldMap :: Monoid m => (i -> a -> m) -> Magma i t b a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Magma i t b a -> m Source # ifoldr :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 Source # ifoldl :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 Source # ifoldr' :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 Source # ifoldl' :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 Source #
FoldableWithIndex [Int] Tree
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m Source # ifoldMap' :: Monoid m => ([Int] -> a -> m) -> Tree a -> m Source # ifoldr :: ([Int] -> a -> b -> b) -> b -> Tree a -> b Source # ifoldl :: ([Int] -> b -> a -> b) -> b -> Tree a -> b Source # ifoldr' :: ([Int] -> a -> b -> b) -> b -> Tree a -> b Source # ifoldl' :: ([Int] -> b -> a -> b) -> b -> Tree a -> b Source #
FoldableWithIndex i f => FoldableWithIndex [i] (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods ifoldMap :: Monoid m => ([i] -> a -> m) -> Cofree f a -> m Source # ifoldMap' :: Monoid m => ([i] -> a -> m) -> Cofree f a -> m Source # ifoldr :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b Source # ifoldl :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b Source # ifoldr' :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b Source # ifoldl' :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b Source #
FoldableWithIndex i f => FoldableWithIndex [i] (Free f)
Instance details Defined in Control.Monad.Free Methods ifoldMap :: Monoid m => ([i] -> a -> m) -> Free f a -> m Source # ifoldMap' :: Monoid m => ([i] -> a -> m) -> Free f a -> m Source # ifoldr :: ([i] -> a -> b -> b) -> b -> Free f a -> b Source # ifoldl :: ([i] -> b -> a -> b) -> b -> Free f a -> b Source # ifoldr' :: ([i] -> a -> b -> b) -> b -> Free f a -> b Source # ifoldl' :: ([i] -> b -> a -> b) -> b -> Free f a -> b Source #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Product f g)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> Product f g a -> m Source # ifoldMap' :: Monoid m => (Either i j -> a -> m) -> Product f g a -> m Source # ifoldr :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b Source # ifoldl :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b Source # ifoldr' :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b Source # ifoldl' :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b Source #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Sum f g)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> Sum f g a -> m Source # ifoldMap' :: Monoid m => (Either i j -> a -> m) -> Sum f g a -> m Source # ifoldr :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b Source # ifoldl :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b Source # ifoldr' :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b Source # ifoldl' :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b Source #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :*: g)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :: g) a -> m Source # ifoldMap' :: Monoid m => (Either i j -> a -> m) -> (f :: g) a -> m Source # ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :: g) a -> b Source # ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :: g) a -> b Source # ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :: g) a -> b Source # ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :: g) a -> b Source #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :+: g)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :+: g) a -> m Source # ifoldMap' :: Monoid m => (Either i j -> a -> m) -> (f :+: g) a -> m Source # ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b Source # ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b Source # ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b Source # ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b Source #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (Compose f g)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => ((i, j) -> a -> m) -> Compose f g a -> m Source # ifoldMap' :: Monoid m => ((i, j) -> a -> m) -> Compose f g a -> m Source # ifoldr :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b Source # ifoldl :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b Source # ifoldr' :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b Source # ifoldl' :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b Source #
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (f :.: g)
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => ((i, j) -> a -> m) -> (f :.: g) a -> m Source # ifoldMap' :: Monoid m => ((i, j) -> a -> m) -> (f :.: g) a -> m Source # ifoldr :: ((i, j) -> a -> b -> b) -> b -> (f :.: g) a -> b Source # ifoldl :: ((i, j) -> b -> a -> b) -> b -> (f :.: g) a -> b Source # ifoldr' :: ((i, j) -> a -> b -> b) -> b -> (f :.: g) a -> b Source # ifoldl' :: ((i, j) -> b -> a -> b) -> b -> (f :.: g) a -> b Source #

class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: Type -> Type) | t -> i where Source #

A Traversable with an additional index.

An instance must satisfy a (modified) form of the Traversable laws:

itraverse (const Identity) ≡ Identity
fmap (itraverse f) . itraverse g ≡ getCompose . itraverse (\i -> Compose . fmap (f i) . g i)

Minimal complete definition

Nothing

Methods

itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b) Source #

Traverse an indexed container.

itraverse ≡ itraverseOf itraversed

Instances

Instances details

TraversableWithIndex () Identity
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (() -> a -> f b) -> Identity a -> f (Identity b) Source #
TraversableWithIndex () Par1
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (() -> a -> f b) -> Par1 a -> f (Par1 b) Source #
TraversableWithIndex () Maybe
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (() -> a -> f b) -> Maybe a -> f (Maybe b) Source #
TraversableWithIndex Int ZipList
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Int -> a -> f b) -> ZipList a -> f (ZipList b) Source #
TraversableWithIndex Int NonEmpty
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b) Source #
TraversableWithIndex Int IntMap
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b) Source #
TraversableWithIndex Int Seq
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b) Source #
TraversableWithIndex Int Deque Source #
Instance details Defined in Control.Lens.Internal.Deque Methods itraverse :: Applicative f => (Int -> a -> f b) -> Deque a -> f (Deque b) Source #
TraversableWithIndex Int []
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b] Source #
TraversableWithIndex Void (Proxy :: Type -> Type)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Void -> a -> f b) -> Proxy a -> f (Proxy b) Source #
TraversableWithIndex Void (U1 :: Type -> Type)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Void -> a -> f b) -> U1 a -> f (U1 b) Source #
TraversableWithIndex Void (V1 :: Type -> Type)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Void -> a -> f b) -> V1 a -> f (V1 b) Source #
Ix i => TraversableWithIndex i (Array i)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (i -> a -> f b) -> Array i a -> f (Array i b) Source #
TraversableWithIndex i (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods itraverse :: Applicative f => (i -> a -> f b) -> Level i a -> f (Level i b) Source #
TraversableWithIndex k (Map k)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (k -> a -> f b) -> Map k a -> f (Map k b) Source #
TraversableWithIndex k ((,) k)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (k -> a -> f b) -> (k, a) -> f (k, b) Source #
TraversableWithIndex Void (Const e :: Type -> Type)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Void -> a -> f b) -> Const e a -> f (Const e b) Source #
TraversableWithIndex Void (Constant e :: Type -> Type)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Void -> a -> f b) -> Constant e a -> f (Constant e b) Source #
TraversableWithIndex i f => TraversableWithIndex i (Rec1 f)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => (i -> a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) Source #
TraversableWithIndex i f => TraversableWithIndex i (Backwards f)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => (i -> a -> f0 b) -> Backwards f a -> f0 (Backwards f b) Source #
TraversableWithIndex i m => TraversableWithIndex i (IdentityT m)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (i -> a -> f b) -> IdentityT m a -> f (IdentityT m b) Source #
TraversableWithIndex i f => TraversableWithIndex i (Reverse f)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => (i -> a -> f0 b) -> Reverse f a -> f0 (Reverse f b) Source #
TraversableWithIndex Void (K1 i c :: Type -> Type)
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Void -> a -> f b) -> K1 i c a -> f (K1 i c b) Source #
TraversableWithIndex i (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods itraverse :: Applicative f => (i -> a -> f b0) -> Magma i t b a -> f (Magma i t b b0) Source #
TraversableWithIndex [Int] Tree
Instance details Defined in WithIndex Methods itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b) Source #
TraversableWithIndex i f => TraversableWithIndex [i] (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods itraverse :: Applicative f0 => ([i] -> a -> f0 b) -> Cofree f a -> f0 (Cofree f b) Source #
TraversableWithIndex i f => TraversableWithIndex [i] (Free f)
Instance details Defined in Control.Monad.Free Methods itraverse :: Applicative f0 => ([i] -> a -> f0 b) -> Free f a -> f0 (Free f b) Source #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Product f g)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Product f g a -> f0 (Product f g b) Source #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Sum f g)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Sum f g a -> f0 (Sum f g b) Source #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :*: g)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) Source #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :+: g)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) Source #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (Compose f g)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => ((i, j) -> a -> f0 b) -> Compose f g a -> f0 (Compose f g b) Source #
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (f :.: g)
Instance details Defined in WithIndex Methods itraverse :: Applicative f0 => ((i, j) -> a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) Source #

class Profunctor p => Choice (p :: Type -> Type -> Type) where Source #

The generalization of Costar of Functor that is strong with respect to Either.

Note: This is also a notion of strength, except with regards to another monoidal structure that we can choose to equip Hask with: the cocartesian coproduct.

Minimal complete definition

left' | right'

Methods

left' :: p a b -> p (Either a c) (Either b c) Source #

Laws:

left' ≡ dimap swapE swapE . right' where
  swapE :: Either a b -> Either b a
  swapE = either Right Left
rmap Left ≡ lmap Left . left'
lmap (right f) . left' ≡ rmap (right f) . left'
left' . left' ≡ dimap assocE unassocE . left' where
  assocE :: Either (Either a b) c -> Either a (Either b c)
  assocE (Left (Left a)) = Left a
  assocE (Left (Right b)) = Right (Left b)
  assocE (Right c) = Right (Right c)
  unassocE :: Either a (Either b c) -> Either (Either a b) c
  unassocE (Left a) = Left (Left a)
  unassocE (Right (Left b)) = Left (Right b)
  unassocE (Right (Right c)) = Right c

right' :: p a b -> p (Either c a) (Either c b) Source #

Laws:

right' ≡ dimap swapE swapE . left' where
  swapE :: Either a b -> Either b a
  swapE = either Right Left
rmap Right ≡ lmap Right . right'
lmap (left f) . right' ≡ rmap (left f) . right'
right' . right' ≡ dimap unassocE assocE . right' where
  assocE :: Either (Either a b) c -> Either a (Either b c)
  assocE (Left (Left a)) = Left a
  assocE (Left (Right b)) = Right (Left b)
  assocE (Right c) = Right (Right c)
  unassocE :: Either a (Either b c) -> Either (Either a b) c
  unassocE (Left a) = Left (Left a)
  unassocE (Right (Left b)) = Left (Right b)
  unassocE (Right (Right c)) = Right c

Instances

Instances details

Choice ReifiedFold Source #
Instance details Defined in Control.Lens.Reified Methods left' :: ReifiedFold a b -> ReifiedFold (Either a c) (Either b c) Source # right' :: ReifiedFold a b -> ReifiedFold (Either c a) (Either c b) Source #
Choice ReifiedGetter Source #
Instance details Defined in Control.Lens.Reified Methods left' :: ReifiedGetter a b -> ReifiedGetter (Either a c) (Either b c) Source # right' :: ReifiedGetter a b -> ReifiedGetter (Either c a) (Either c b) Source #
Monad m => Choice (Kleisli m)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Kleisli m a b -> Kleisli m (Either a c) (Either b c) Source # right' :: Kleisli m a b -> Kleisli m (Either c a) (Either c b) Source #
Choice (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods left' :: Indexed i a b -> Indexed i (Either a c) (Either b c) Source # right' :: Indexed i a b -> Indexed i (Either c a) (Either c b) Source #
Choice (PastroSum p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: PastroSum p a b -> PastroSum p (Either a c) (Either b c) Source # right' :: PastroSum p a b -> PastroSum p (Either c a) (Either c b) Source #
Profunctor p => Choice (TambaraSum p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: TambaraSum p a b -> TambaraSum p (Either a c) (Either b c) Source # right' :: TambaraSum p a b -> TambaraSum p (Either c a) (Either c b) Source #
Profunctor p => Choice (CofreeMapping p)
Instance details Defined in Data.Profunctor.Mapping Methods left' :: CofreeMapping p a b -> CofreeMapping p (Either a c) (Either b c) Source # right' :: CofreeMapping p a b -> CofreeMapping p (Either c a) (Either c b) Source #
Choice (FreeMapping p)
Instance details Defined in Data.Profunctor.Mapping Methods left' :: FreeMapping p a b -> FreeMapping p (Either a c) (Either b c) Source # right' :: FreeMapping p a b -> FreeMapping p (Either c a) (Either c b) Source #
Choice p => Choice (Tambara p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Tambara p a b -> Tambara p (Either a c) (Either b c) Source # right' :: Tambara p a b -> Tambara p (Either c a) (Either c b) Source #
Profunctor p => Choice (CofreeTraversing p)
Instance details Defined in Data.Profunctor.Traversing Methods left' :: CofreeTraversing p a b -> CofreeTraversing p (Either a c) (Either b c) Source # right' :: CofreeTraversing p a b -> CofreeTraversing p (Either c a) (Either c b) Source #
Choice (FreeTraversing p)
Instance details Defined in Data.Profunctor.Traversing Methods left' :: FreeTraversing p a b -> FreeTraversing p (Either a c) (Either b c) Source # right' :: FreeTraversing p a b -> FreeTraversing p (Either c a) (Either c b) Source #
Choice (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Tagged a b -> Tagged (Either a c) (Either b c) Source # right' :: Tagged a b -> Tagged (Either c a) (Either c b) Source #
Comonad w => Choice (Cokleisli w)	`extract` approximates `costrength`
Instance details Defined in Data.Profunctor.Choice Methods left' :: Cokleisli w a b -> Cokleisli w (Either a c) (Either b c) Source # right' :: Cokleisli w a b -> Cokleisli w (Either c a) (Either c b) Source #
Choice (Market a b) Source #
Instance details Defined in Control.Lens.Internal.Prism Methods left' :: Market a b a0 b0 -> Market a b (Either a0 c) (Either b0 c) Source # right' :: Market a b a0 b0 -> Market a b (Either c a0) (Either c b0) Source #
(Applicative f, Choice p) => Choice (WrappedPafb f p) Source #
Instance details Defined in Control.Lens.Internal.Profunctor Methods left' :: WrappedPafb f p a b -> WrappedPafb f p (Either a c) (Either b c) Source # right' :: WrappedPafb f p a b -> WrappedPafb f p (Either c a) (Either c b) Source #
Monoid r => Choice (Forget r :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Forget r a b -> Forget r (Either a c) (Either b c) Source # right' :: Forget r a b -> Forget r (Either c a) (Either c b) Source #
Applicative f => Choice (Star f)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Star f a b -> Star f (Either a c) (Either b c) Source # right' :: Star f a b -> Star f (Either c a) (Either c b) Source #
Choice (->)
Instance details Defined in Data.Profunctor.Choice Methods left' :: (a -> b) -> Either a c -> Either b c Source # right' :: (a -> b) -> Either c a -> Either c b Source #
Functor f => Choice (Joker f :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Joker f a b -> Joker f (Either a c) (Either b c) Source # right' :: Joker f a b -> Joker f (Either c a) (Either c b) Source #
ArrowChoice p => Choice (WrappedArrow p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: WrappedArrow p a b -> WrappedArrow p (Either a c) (Either b c) Source # right' :: WrappedArrow p a b -> WrappedArrow p (Either c a) (Either c b) Source #
(Choice p, Choice q) => Choice (Product p q)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Product p q a b -> Product p q (Either a c) (Either b c) Source # right' :: Product p q a b -> Product p q (Either c a) (Either c b) Source #
(Choice p, Choice q) => Choice (Sum p q)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Sum p q a b -> Sum p q (Either a c) (Either b c) Source # right' :: Sum p q a b -> Sum p q (Either c a) (Either c b) Source #
(Functor f, Choice p) => Choice (Tannen f p)
Instance details Defined in Data.Profunctor.Choice Methods left' :: Tannen f p a b -> Tannen f p (Either a c) (Either b c) Source # right' :: Tannen f p a b -> Tannen f p (Either c a) (Either c b) Source #
(Functor f, Choice p) => Choice (Cayley f p)
Instance details Defined in Data.Profunctor.Cayley Methods left' :: Cayley f p a b -> Cayley f p (Either a c) (Either b c) Source # right' :: Cayley f p a b -> Cayley f p (Either c a) (Either c b) Source #
(Choice p, Choice q) => Choice (Procompose p q)
Instance details Defined in Data.Profunctor.Composition Methods left' :: Procompose p q a b -> Procompose p q (Either a c) (Either b c) Source # right' :: Procompose p q a b -> Procompose p q (Either c a) (Either c b) Source #

class Profunctor (p :: Type -> Type -> Type) where Source #

Formally, the class Profunctor represents a profunctor from Hask -> Hask.

Intuitively it is a bifunctor where the first argument is contravariant and the second argument is covariant.

You can define a Profunctor by either defining dimap or by defining both lmap and rmap.

If you supply dimap, you should ensure that:

dimap id id ≡ id

If you supply lmap and rmap, ensure:

lmap id ≡ id
rmap id ≡ id

If you supply both, you should also ensure:

dimap f g ≡ lmap f . rmap g

These ensure by parametricity:

dimap (f . g) (h . i) ≡ dimap g h . dimap f i
lmap (f . g) ≡ lmap g . lmap f
rmap (f . g) ≡ rmap f . rmap g

Minimal complete definition

dimap | lmap, rmap

Methods

dimap :: (a -> b) -> (c -> d) -> p b c -> p a d Source #

Map over both arguments at the same time.

dimap f g ≡ lmap f . rmap g

lmap :: (a -> b) -> p b c -> p a c Source #

Map the first argument contravariantly.

lmap f ≡ dimap f id

rmap :: (b -> c) -> p a b -> p a c Source #

Map the second argument covariantly.

rmap ≡ dimap id

Instances

Instances details

Profunctor ReifiedFold Source #
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedFold b c -> ReifiedFold a d Source # lmap :: (a -> b) -> ReifiedFold b c -> ReifiedFold a c Source # rmap :: (b -> c) -> ReifiedFold a b -> ReifiedFold a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> ReifiedFold a b -> ReifiedFold a c Source # (.#) :: forall a b c q. Coercible b a => ReifiedFold b c -> q a b -> ReifiedFold a c Source #
Profunctor ReifiedGetter Source #
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedGetter b c -> ReifiedGetter a d Source # lmap :: (a -> b) -> ReifiedGetter b c -> ReifiedGetter a c Source # rmap :: (b -> c) -> ReifiedGetter a b -> ReifiedGetter a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> ReifiedGetter a b -> ReifiedGetter a c Source # (.#) :: forall a b c q. Coercible b a => ReifiedGetter b c -> q a b -> ReifiedGetter a c Source #
Monad m => Profunctor (Kleisli m)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Kleisli m b c -> Kleisli m a d Source # lmap :: (a -> b) -> Kleisli m b c -> Kleisli m a c Source # rmap :: (b -> c) -> Kleisli m a b -> Kleisli m a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Kleisli m a b -> Kleisli m a c Source # (.#) :: forall a b c q. Coercible b a => Kleisli m b c -> q a b -> Kleisli m a c Source #
Profunctor (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods dimap :: (a -> b) -> (c -> d) -> Indexed i b c -> Indexed i a d Source # lmap :: (a -> b) -> Indexed i b c -> Indexed i a c Source # rmap :: (b -> c) -> Indexed i a b -> Indexed i a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Indexed i a b -> Indexed i a c Source # (.#) :: forall a b c q. Coercible b a => Indexed i b c -> q a b -> Indexed i a c Source #
Profunctor (ReifiedIndexedFold i) Source #
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a d Source # lmap :: (a -> b) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a c Source # rmap :: (b -> c) -> ReifiedIndexedFold i a b -> ReifiedIndexedFold i a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> ReifiedIndexedFold i a b -> ReifiedIndexedFold i a c Source # (.#) :: forall a b c q. Coercible b a => ReifiedIndexedFold i b c -> q a b -> ReifiedIndexedFold i a c Source #
Profunctor (ReifiedIndexedGetter i) Source #
Instance details Defined in Control.Lens.Reified Methods dimap :: (a -> b) -> (c -> d) -> ReifiedIndexedGetter i b c -> ReifiedIndexedGetter i a d Source # lmap :: (a -> b) -> ReifiedIndexedGetter i b c -> ReifiedIndexedGetter i a c Source # rmap :: (b -> c) -> ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i a c Source # (.#) :: forall a b c q. Coercible b a => ReifiedIndexedGetter i b c -> q a b -> ReifiedIndexedGetter i a c Source #
Profunctor (CopastroSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> CopastroSum p b c -> CopastroSum p a d Source # lmap :: (a -> b) -> CopastroSum p b c -> CopastroSum p a c Source # rmap :: (b -> c) -> CopastroSum p a b -> CopastroSum p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> CopastroSum p a b -> CopastroSum p a c Source # (.#) :: forall a b c q. Coercible b a => CopastroSum p b c -> q a b -> CopastroSum p a c Source #
Profunctor (CotambaraSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> CotambaraSum p b c -> CotambaraSum p a d Source # lmap :: (a -> b) -> CotambaraSum p b c -> CotambaraSum p a c Source # rmap :: (b -> c) -> CotambaraSum p a b -> CotambaraSum p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> CotambaraSum p a b -> CotambaraSum p a c Source # (.#) :: forall a b c q. Coercible b a => CotambaraSum p b c -> q a b -> CotambaraSum p a c Source #
Profunctor (PastroSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> PastroSum p b c -> PastroSum p a d Source # lmap :: (a -> b) -> PastroSum p b c -> PastroSum p a c Source # rmap :: (b -> c) -> PastroSum p a b -> PastroSum p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> PastroSum p a b -> PastroSum p a c Source # (.#) :: forall a b c q. Coercible b a => PastroSum p b c -> q a b -> PastroSum p a c Source #
Profunctor p => Profunctor (TambaraSum p)
Instance details Defined in Data.Profunctor.Choice Methods dimap :: (a -> b) -> (c -> d) -> TambaraSum p b c -> TambaraSum p a d Source # lmap :: (a -> b) -> TambaraSum p b c -> TambaraSum p a c Source # rmap :: (b -> c) -> TambaraSum p a b -> TambaraSum p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> TambaraSum p a b -> TambaraSum p a c Source # (.#) :: forall a b c q. Coercible b a => TambaraSum p b c -> q a b -> TambaraSum p a c Source #
Profunctor p => Profunctor (Closure p)
Instance details Defined in Data.Profunctor.Closed Methods dimap :: (a -> b) -> (c -> d) -> Closure p b c -> Closure p a d Source # lmap :: (a -> b) -> Closure p b c -> Closure p a c Source # rmap :: (b -> c) -> Closure p a b -> Closure p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Closure p a b -> Closure p a c Source # (.#) :: forall a b c q. Coercible b a => Closure p b c -> q a b -> Closure p a c Source #
Profunctor (Environment p)
Instance details Defined in Data.Profunctor.Closed Methods dimap :: (a -> b) -> (c -> d) -> Environment p b c -> Environment p a d Source # lmap :: (a -> b) -> Environment p b c -> Environment p a c Source # rmap :: (b -> c) -> Environment p a b -> Environment p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Environment p a b -> Environment p a c Source # (.#) :: forall a b c q. Coercible b a => Environment p b c -> q a b -> Environment p a c Source #
Profunctor p => Profunctor (CofreeMapping p)
Instance details Defined in Data.Profunctor.Mapping Methods dimap :: (a -> b) -> (c -> d) -> CofreeMapping p b c -> CofreeMapping p a d Source # lmap :: (a -> b) -> CofreeMapping p b c -> CofreeMapping p a c Source # rmap :: (b -> c) -> CofreeMapping p a b -> CofreeMapping p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> CofreeMapping p a b -> CofreeMapping p a c Source # (.#) :: forall a b c q. Coercible b a => CofreeMapping p b c -> q a b -> CofreeMapping p a c Source #
Profunctor (FreeMapping p)
Instance details Defined in Data.Profunctor.Mapping Methods dimap :: (a -> b) -> (c -> d) -> FreeMapping p b c -> FreeMapping p a d Source # lmap :: (a -> b) -> FreeMapping p b c -> FreeMapping p a c Source # rmap :: (b -> c) -> FreeMapping p a b -> FreeMapping p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> FreeMapping p a b -> FreeMapping p a c Source # (.#) :: forall a b c q. Coercible b a => FreeMapping p b c -> q a b -> FreeMapping p a c Source #
Profunctor (Copastro p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Copastro p b c -> Copastro p a d Source # lmap :: (a -> b) -> Copastro p b c -> Copastro p a c Source # rmap :: (b -> c) -> Copastro p a b -> Copastro p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Copastro p a b -> Copastro p a c Source # (.#) :: forall a b c q. Coercible b a => Copastro p b c -> q a b -> Copastro p a c Source #
Profunctor (Cotambara p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Cotambara p b c -> Cotambara p a d Source # lmap :: (a -> b) -> Cotambara p b c -> Cotambara p a c Source # rmap :: (b -> c) -> Cotambara p a b -> Cotambara p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Cotambara p a b -> Cotambara p a c Source # (.#) :: forall a b c q. Coercible b a => Cotambara p b c -> q a b -> Cotambara p a c Source #
Profunctor (Pastro p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Pastro p b c -> Pastro p a d Source # lmap :: (a -> b) -> Pastro p b c -> Pastro p a c Source # rmap :: (b -> c) -> Pastro p a b -> Pastro p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Pastro p a b -> Pastro p a c Source # (.#) :: forall a b c q. Coercible b a => Pastro p b c -> q a b -> Pastro p a c Source #
Profunctor p => Profunctor (Tambara p)
Instance details Defined in Data.Profunctor.Strong Methods dimap :: (a -> b) -> (c -> d) -> Tambara p b c -> Tambara p a d Source # lmap :: (a -> b) -> Tambara p b c -> Tambara p a c Source # rmap :: (b -> c) -> Tambara p a b -> Tambara p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Tambara p a b -> Tambara p a c Source # (.#) :: forall a b c q. Coercible b a => Tambara p b c -> q a b -> Tambara p a c Source #
Profunctor (Baz t)
Instance details Defined in Data.Profunctor.Traversing Methods dimap :: (a -> b) -> (c -> d) -> Baz t b c -> Baz t a d Source # lmap :: (a -> b) -> Baz t b c -> Baz t a c Source # rmap :: (b -> c) -> Baz t a b -> Baz t a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Baz t a b -> Baz t a c Source # (.#) :: forall a b c q. Coercible b a => Baz t b c -> q a b -> Baz t a c Source #
Profunctor (Bazaar a)
Instance details Defined in Data.Profunctor.Traversing Methods dimap :: (a0 -> b) -> (c -> d) -> Bazaar a b c -> Bazaar a a0 d Source # lmap :: (a0 -> b) -> Bazaar a b c -> Bazaar a a0 c Source # rmap :: (b -> c) -> Bazaar a a0 b -> Bazaar a a0 c Source # (#.) :: forall a0 b c q. Coercible c b => q b c -> Bazaar a a0 b -> Bazaar a a0 c Source # (.#) :: forall a0 b c q. Coercible b a0 => Bazaar a b c -> q a0 b -> Bazaar a a0 c Source #
Profunctor p => Profunctor (CofreeTraversing p)
Instance details Defined in Data.Profunctor.Traversing Methods dimap :: (a -> b) -> (c -> d) -> CofreeTraversing p b c -> CofreeTraversing p a d Source # lmap :: (a -> b) -> CofreeTraversing p b c -> CofreeTraversing p a c Source # rmap :: (b -> c) -> CofreeTraversing p a b -> CofreeTraversing p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> CofreeTraversing p a b -> CofreeTraversing p a c Source # (.#) :: forall a b c q. Coercible b a => CofreeTraversing p b c -> q a b -> CofreeTraversing p a c Source #
Profunctor (FreeTraversing p)
Instance details Defined in Data.Profunctor.Traversing Methods dimap :: (a -> b) -> (c -> d) -> FreeTraversing p b c -> FreeTraversing p a d Source # lmap :: (a -> b) -> FreeTraversing p b c -> FreeTraversing p a c Source # rmap :: (b -> c) -> FreeTraversing p a b -> FreeTraversing p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> FreeTraversing p a b -> FreeTraversing p a c Source # (.#) :: forall a b c q. Coercible b a => FreeTraversing p b c -> q a b -> FreeTraversing p a c Source #
Profunctor (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Tagged b c -> Tagged a d Source # lmap :: (a -> b) -> Tagged b c -> Tagged a c Source # rmap :: (b -> c) -> Tagged a b -> Tagged a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Tagged a b -> Tagged a c Source # (.#) :: forall a b c q. Coercible b a => Tagged b c -> q a b -> Tagged a c Source #
Functor w => Profunctor (Cokleisli w)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Cokleisli w b c -> Cokleisli w a d Source # lmap :: (a -> b) -> Cokleisli w b c -> Cokleisli w a c Source # rmap :: (b -> c) -> Cokleisli w a b -> Cokleisli w a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Cokleisli w a b -> Cokleisli w a c Source # (.#) :: forall a b c q. Coercible b a => Cokleisli w b c -> q a b -> Cokleisli w a c Source #
Profunctor (Exchange a b) Source #
Instance details Defined in Control.Lens.Internal.Iso Methods dimap :: (a0 -> b0) -> (c -> d) -> Exchange a b b0 c -> Exchange a b a0 d Source # lmap :: (a0 -> b0) -> Exchange a b b0 c -> Exchange a b a0 c Source # rmap :: (b0 -> c) -> Exchange a b a0 b0 -> Exchange a b a0 c Source # (#.) :: forall a0 b0 c q. Coercible c b0 => q b0 c -> Exchange a b a0 b0 -> Exchange a b a0 c Source # (.#) :: forall a0 b0 c q. Coercible b0 a0 => Exchange a b b0 c -> q a0 b0 -> Exchange a b a0 c Source #
Profunctor (Market a b) Source #
Instance details Defined in Control.Lens.Internal.Prism Methods dimap :: (a0 -> b0) -> (c -> d) -> Market a b b0 c -> Market a b a0 d Source # lmap :: (a0 -> b0) -> Market a b b0 c -> Market a b a0 c Source # rmap :: (b0 -> c) -> Market a b a0 b0 -> Market a b a0 c Source # (#.) :: forall a0 b0 c q. Coercible c b0 => q b0 c -> Market a b a0 b0 -> Market a b a0 c Source # (.#) :: forall a0 b0 c q. Coercible b0 a0 => Market a b b0 c -> q a0 b0 -> Market a b a0 c Source #
(Functor f, Profunctor p) => Profunctor (WrappedPafb f p) Source #
Instance details Defined in Control.Lens.Internal.Profunctor Methods dimap :: (a -> b) -> (c -> d) -> WrappedPafb f p b c -> WrappedPafb f p a d Source # lmap :: (a -> b) -> WrappedPafb f p b c -> WrappedPafb f p a c Source # rmap :: (b -> c) -> WrappedPafb f p a b -> WrappedPafb f p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> WrappedPafb f p a b -> WrappedPafb f p a c Source # (.#) :: forall a b c q. Coercible b a => WrappedPafb f p b c -> q a b -> WrappedPafb f p a c Source #
Functor f => Profunctor (Costar f)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> Costar f b c -> Costar f a d Source # lmap :: (a -> b) -> Costar f b c -> Costar f a c Source # rmap :: (b -> c) -> Costar f a b -> Costar f a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Costar f a b -> Costar f a c Source # (.#) :: forall a b c q. Coercible b a => Costar f b c -> q a b -> Costar f a c Source #
Profunctor (Forget r :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> Forget r b c -> Forget r a d Source # lmap :: (a -> b) -> Forget r b c -> Forget r a c Source # rmap :: (b -> c) -> Forget r a b -> Forget r a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Forget r a b -> Forget r a c Source # (.#) :: forall a b c q. Coercible b a => Forget r b c -> q a b -> Forget r a c Source #
Functor f => Profunctor (Star f)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> Star f b c -> Star f a d Source # lmap :: (a -> b) -> Star f b c -> Star f a c Source # rmap :: (b -> c) -> Star f a b -> Star f a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Star f a b -> Star f a c Source # (.#) :: forall a b c q. Coercible b a => Star f b c -> q a b -> Star f a c Source #
Profunctor (->)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> (b -> c) -> a -> d Source # lmap :: (a -> b) -> (b -> c) -> a -> c Source # rmap :: (b -> c) -> (a -> b) -> a -> c Source # (#.) :: forall a b c q. Coercible c b => q b c -> (a -> b) -> a -> c Source # (.#) :: forall a b c q. Coercible b a => (b -> c) -> q a b -> a -> c Source #
Contravariant f => Profunctor (Clown f :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Clown f b c -> Clown f a d Source # lmap :: (a -> b) -> Clown f b c -> Clown f a c Source # rmap :: (b -> c) -> Clown f a b -> Clown f a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Clown f a b -> Clown f a c Source # (.#) :: forall a b c q. Coercible b a => Clown f b c -> q a b -> Clown f a c Source #
Functor f => Profunctor (Joker f :: Type -> Type -> Type)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Joker f b c -> Joker f a d Source # lmap :: (a -> b) -> Joker f b c -> Joker f a c Source # rmap :: (b -> c) -> Joker f a b -> Joker f a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Joker f a b -> Joker f a c Source # (.#) :: forall a b c q. Coercible b a => Joker f b c -> q a b -> Joker f a c Source #
Arrow p => Profunctor (WrappedArrow p)
Instance details Defined in Data.Profunctor.Types Methods dimap :: (a -> b) -> (c -> d) -> WrappedArrow p b c -> WrappedArrow p a d Source # lmap :: (a -> b) -> WrappedArrow p b c -> WrappedArrow p a c Source # rmap :: (b -> c) -> WrappedArrow p a b -> WrappedArrow p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> WrappedArrow p a b -> WrappedArrow p a c Source # (.#) :: forall a b c q. Coercible b a => WrappedArrow p b c -> q a b -> WrappedArrow p a c Source #
(Profunctor p, Profunctor q) => Profunctor (Product p q)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Product p q b c -> Product p q a d Source # lmap :: (a -> b) -> Product p q b c -> Product p q a c Source # rmap :: (b -> c) -> Product p q a b -> Product p q a c Source # (#.) :: forall a b c q0. Coercible c b => q0 b c -> Product p q a b -> Product p q a c Source # (.#) :: forall a b c q0. Coercible b a => Product p q b c -> q0 a b -> Product p q a c Source #
(Profunctor p, Profunctor q) => Profunctor (Sum p q)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Sum p q b c -> Sum p q a d Source # lmap :: (a -> b) -> Sum p q b c -> Sum p q a c Source # rmap :: (b -> c) -> Sum p q a b -> Sum p q a c Source # (#.) :: forall a b c q0. Coercible c b => q0 b c -> Sum p q a b -> Sum p q a c Source # (.#) :: forall a b c q0. Coercible b a => Sum p q b c -> q0 a b -> Sum p q a c Source #
(Functor f, Profunctor p) => Profunctor (Tannen f p)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Tannen f p b c -> Tannen f p a d Source # lmap :: (a -> b) -> Tannen f p b c -> Tannen f p a c Source # rmap :: (b -> c) -> Tannen f p a b -> Tannen f p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Tannen f p a b -> Tannen f p a c Source # (.#) :: forall a b c q. Coercible b a => Tannen f p b c -> q a b -> Tannen f p a c Source #
(Functor f, Profunctor p) => Profunctor (Cayley f p)
Instance details Defined in Data.Profunctor.Cayley Methods dimap :: (a -> b) -> (c -> d) -> Cayley f p b c -> Cayley f p a d Source # lmap :: (a -> b) -> Cayley f p b c -> Cayley f p a c Source # rmap :: (b -> c) -> Cayley f p a b -> Cayley f p a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Cayley f p a b -> Cayley f p a c Source # (.#) :: forall a b c q. Coercible b a => Cayley f p b c -> q a b -> Cayley f p a c Source #
(Profunctor p, Profunctor q) => Profunctor (Procompose p q)
Instance details Defined in Data.Profunctor.Composition Methods dimap :: (a -> b) -> (c -> d) -> Procompose p q b c -> Procompose p q a d Source # lmap :: (a -> b) -> Procompose p q b c -> Procompose p q a c Source # rmap :: (b -> c) -> Procompose p q a b -> Procompose p q a c Source # (#.) :: forall a b c q0. Coercible c b => q0 b c -> Procompose p q a b -> Procompose p q a c Source # (.#) :: forall a b c q0. Coercible b a => Procompose p q b c -> q0 a b -> Procompose p q a c Source #
(Profunctor p, Profunctor q) => Profunctor (Rift p q)
Instance details Defined in Data.Profunctor.Composition Methods dimap :: (a -> b) -> (c -> d) -> Rift p q b c -> Rift p q a d Source # lmap :: (a -> b) -> Rift p q b c -> Rift p q a c Source # rmap :: (b -> c) -> Rift p q a b -> Rift p q a c Source # (#.) :: forall a b c q0. Coercible c b => q0 b c -> Rift p q a b -> Rift p q a c Source # (.#) :: forall a b c q0. Coercible b a => Rift p q b c -> q0 a b -> Rift p q a c Source #
(Profunctor p, Functor f, Functor g) => Profunctor (Biff p f g)
Instance details Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Biff p f g b c -> Biff p f g a d Source # lmap :: (a -> b) -> Biff p f g b c -> Biff p f g a c Source # rmap :: (b -> c) -> Biff p f g a b -> Biff p f g a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Biff p f g a b -> Biff p f g a c Source # (.#) :: forall a b c q. Coercible b a => Biff p f g b c -> q a b -> Biff p f g a c Source #

sequenceBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> t (f a) -> f (t a) Source #

Sequence a container using its Traversable instance using explicitly provided Applicative operations. This is like sequence where the Applicative instance can be manually specified.

traverseBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b) Source #

Traverse a container using its Traversable instance using explicitly provided Applicative operations. This is like traverse where the Applicative instance can be manually specified.

foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r Source #

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like foldMap where the Monoid instance can be manually specified.

foldMapBy mappend mempty ≡ foldMap

>>> foldMapBy (+) 0 length ["hello","world"]
10

foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a Source #

Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like fold where the Monoid instance can be manually specified.

foldBy mappend mempty ≡ fold

>>> foldBy (++) [] ["hello","world"]
"helloworld"

class (Foldable1 t, Traversable t) => Traversable1 (t :: Type -> Type) where Source #

Minimal complete definition

traverse1 | sequence1

Methods

traverse1 :: Apply f => (a -> f b) -> t a -> f (t b) Source #

Instances

Instances details

Traversable1 Complex
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Complex a -> f (Complex b) Source # sequence1 :: Apply f => Complex (f b) -> f (Complex b) Source #
Traversable1 Identity
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) Source # sequence1 :: Apply f => Identity (f b) -> f (Identity b) Source #
Traversable1 First
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> First a -> f (First b) Source # sequence1 :: Apply f => First (f b) -> f (First b) Source #
Traversable1 Last
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Last a -> f (Last b) Source # sequence1 :: Apply f => Last (f b) -> f (Last b) Source #
Traversable1 Max
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Max a -> f (Max b) Source # sequence1 :: Apply f => Max (f b) -> f (Max b) Source #
Traversable1 Min
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Min a -> f (Min b) Source # sequence1 :: Apply f => Min (f b) -> f (Min b) Source #
Traversable1 Dual
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Dual a -> f (Dual b) Source # sequence1 :: Apply f => Dual (f b) -> f (Dual b) Source #
Traversable1 Product
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Product a -> f (Product b) Source # sequence1 :: Apply f => Product (f b) -> f (Product b) Source #
Traversable1 Sum
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Sum a -> f (Sum b) Source # sequence1 :: Apply f => Sum (f b) -> f (Sum b) Source #
Traversable1 NonEmpty
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) Source # sequence1 :: Apply f => NonEmpty (f b) -> f (NonEmpty b) Source #
Traversable1 Par1
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Par1 a -> f (Par1 b) Source # sequence1 :: Apply f => Par1 (f b) -> f (Par1 b) Source #
Traversable1 Tree
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Tree a -> f (Tree b) Source # sequence1 :: Apply f => Tree (f b) -> f (Tree b) Source #
Traversable1 (V1 :: Type -> Type)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> V1 a -> f (V1 b) Source # sequence1 :: Apply f => V1 (f b) -> f (V1 b) Source #
Traversable1 f => Traversable1 (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods traverse1 :: Apply f0 => (a -> f0 b) -> Cofree f a -> f0 (Cofree f b) Source # sequence1 :: Apply f0 => Cofree f (f0 b) -> f0 (Cofree f b) Source #
Traversable1 f => Traversable1 (Free f)
Instance details Defined in Control.Monad.Free Methods traverse1 :: Apply f0 => (a -> f0 b) -> Free f a -> f0 (Free f b) Source # sequence1 :: Apply f0 => Free f (f0 b) -> f0 (Free f b) Source #
Traversable1 f => Traversable1 (F f)
Instance details Defined in Control.Monad.Free.Church Methods traverse1 :: Apply f0 => (a -> f0 b) -> F f a -> f0 (F f b) Source # sequence1 :: Apply f0 => F f (f0 b) -> f0 (F f b) Source #
(Monad m, Traversable1 m) => Traversable1 (IterT m)
Instance details Defined in Control.Monad.Trans.Iter Methods traverse1 :: Apply f => (a -> f b) -> IterT m a -> f (IterT m b) Source # sequence1 :: Apply f => IterT m (f b) -> f (IterT m b) Source #
Traversable1 f => Traversable1 (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods traverse1 :: Apply f0 => (a -> f0 b) -> Yoneda f a -> f0 (Yoneda f b) Source # sequence1 :: Apply f0 => Yoneda f (f0 b) -> f0 (Yoneda f b) Source #
Traversable1 f => Traversable1 (Lift f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Lift f a -> f0 (Lift f b) Source # sequence1 :: Apply f0 => Lift f (f0 b) -> f0 (Lift f b) Source #
Traversable1 ((,) a)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a0 -> f b) -> (a, a0) -> f (a, b) Source # sequence1 :: Apply f => (a, f b) -> f (a, b) Source #
Traversable1 f => Traversable1 (Alt f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) Source # sequence1 :: Apply f0 => Alt f (f0 b) -> f0 (Alt f b) Source #
Traversable1 f => Traversable1 (Rec1 f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) Source # sequence1 :: Apply f0 => Rec1 f (f0 b) -> f0 (Rec1 f b) Source #
Bitraversable1 p => Traversable1 (Join p)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a -> f b) -> Join p a -> f (Join p b) Source # sequence1 :: Apply f => Join p (f b) -> f (Join p b) Source #
Traversable1 f => Traversable1 (AlongsideLeft f b) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods traverse1 :: Apply f0 => (a -> f0 b0) -> AlongsideLeft f b a -> f0 (AlongsideLeft f b b0) Source # sequence1 :: Apply f0 => AlongsideLeft f b (f0 b0) -> f0 (AlongsideLeft f b b0) Source #
Traversable1 f => Traversable1 (AlongsideRight f a) Source #
Instance details Defined in Control.Lens.Internal.Getter Methods traverse1 :: Apply f0 => (a0 -> f0 b) -> AlongsideRight f a a0 -> f0 (AlongsideRight f a b) Source # sequence1 :: Apply f0 => AlongsideRight f a (f0 b) -> f0 (AlongsideRight f a b) Source #
Traversable1 (Tagged a)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a0 -> f b) -> Tagged a a0 -> f (Tagged a b) Source # sequence1 :: Apply f => Tagged a (f b) -> f (Tagged a b) Source #
Traversable1 f => Traversable1 (Backwards f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Backwards f a -> f0 (Backwards f b) Source # sequence1 :: Apply f0 => Backwards f (f0 b) -> f0 (Backwards f b) Source #
Traversable1 f => Traversable1 (IdentityT f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) Source # sequence1 :: Apply f0 => IdentityT f (f0 b) -> f0 (IdentityT f b) Source #
Traversable1 f => Traversable1 (Reverse f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Reverse f a -> f0 (Reverse f b) Source # sequence1 :: Apply f0 => Reverse f (f0 b) -> f0 (Reverse f b) Source #
(Traversable1 f, Traversable1 g) => Traversable1 (Product f g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b) Source # sequence1 :: Apply f0 => Product f g (f0 b) -> f0 (Product f g b) Source #
(Traversable1 f, Traversable1 g) => Traversable1 (Sum f g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) Source # sequence1 :: Apply f0 => Sum f g (f0 b) -> f0 (Sum f g b) Source #
(Traversable1 f, Traversable1 g) => Traversable1 (f :*: g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) Source # sequence1 :: Apply f0 => (f :: g) (f0 b) -> f0 ((f :: g) b) Source #
(Traversable1 f, Traversable1 g) => Traversable1 (f :+: g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) Source # sequence1 :: Apply f0 => (f :+: g) (f0 b) -> f0 ((f :+: g) b) Source #
(Traversable1 f, Traversable1 g) => Traversable1 (Compose f g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) Source # sequence1 :: Apply f0 => Compose f g (f0 b) -> f0 (Compose f g b) Source #
(Traversable1 f, Traversable1 g) => Traversable1 (f :.: g)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) Source # sequence1 :: Apply f0 => (f :.: g) (f0 b) -> f0 ((f :.: g) b) Source #
Traversable1 f => Traversable1 (M1 i c f)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) Source # sequence1 :: Apply f0 => M1 i c f (f0 b) -> f0 (M1 i c f b) Source #
Traversable1 g => Traversable1 (Joker g a)
Instance details Defined in Data.Semigroup.Traversable.Class Methods traverse1 :: Apply f => (a0 -> f b) -> Joker g a a0 -> f (Joker g a b) Source # sequence1 :: Apply f => Joker g a (f b) -> f (Joker g a b) Source #

class Reversing t where Source #

This class provides a generalized notion of list reversal extended to other containers.

Methods

reversing :: t -> t Source #

Instances

Instances details

Reversing ByteString Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: ByteString -> ByteString Source #
Reversing ByteString Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: ByteString -> ByteString Source #
Reversing Text Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Text -> Text Source #
Reversing Text Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Text -> Text Source #
Reversing (NonEmpty a) Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: NonEmpty a -> NonEmpty a Source #
Reversing (Seq a) Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Seq a -> Seq a Source #
Reversing (Deque a) Source #
Instance details Defined in Control.Lens.Internal.Deque Methods reversing :: Deque a -> Deque a Source #
Reversing (Vector a) Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a Source #
Prim a => Reversing (Vector a) Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a Source #
Storable a => Reversing (Vector a) Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a Source #
Unbox a => Reversing (Vector a) Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: Vector a -> Vector a Source #
Reversing [a] Source #
Instance details Defined in Control.Lens.Internal.Iso Methods reversing :: [a] -> [a] Source #

data Level i a Source #

This data type represents a path-compressed copy of one level of a source data structure. We can safely use path-compression because we know the depth of the tree.

Path compression is performed by viewing a Level as a PATRICIA trie of the paths into the structure to leaves at a given depth, similar in many ways to a IntMap, but unlike a regular PATRICIA trie we do not need to store the mask bits merely the depth of the fork.

One invariant of this structure is that underneath a Two node you will not find any Zero nodes, so Zero can only occur at the root.

Instances

Instances details

FoldableWithIndex i (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods ifoldMap :: Monoid m => (i -> a -> m) -> Level i a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Level i a -> m Source # ifoldr :: (i -> a -> b -> b) -> b -> Level i a -> b Source # ifoldl :: (i -> b -> a -> b) -> b -> Level i a -> b Source # ifoldr' :: (i -> a -> b -> b) -> b -> Level i a -> b Source # ifoldl' :: (i -> b -> a -> b) -> b -> Level i a -> b Source #
FunctorWithIndex i (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods imap :: (i -> a -> b) -> Level i a -> Level i b Source #
TraversableWithIndex i (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods itraverse :: Applicative f => (i -> a -> f b) -> Level i a -> f (Level i b) Source #
Foldable (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods fold :: Monoid m => Level i m -> m Source # foldMap :: Monoid m => (a -> m) -> Level i a -> m Source # foldMap' :: Monoid m => (a -> m) -> Level i a -> m Source # foldr :: (a -> b -> b) -> b -> Level i a -> b Source # foldr' :: (a -> b -> b) -> b -> Level i a -> b Source # foldl :: (b -> a -> b) -> b -> Level i a -> b Source # foldl' :: (b -> a -> b) -> b -> Level i a -> b Source # foldr1 :: (a -> a -> a) -> Level i a -> a Source # foldl1 :: (a -> a -> a) -> Level i a -> a Source # toList :: Level i a -> [a] Source # null :: Level i a -> Bool Source # length :: Level i a -> Int Source # elem :: Eq a => a -> Level i a -> Bool Source # maximum :: Ord a => Level i a -> a Source # minimum :: Ord a => Level i a -> a Source # sum :: Num a => Level i a -> a Source # product :: Num a => Level i a -> a Source #
Traversable (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods traverse :: Applicative f => (a -> f b) -> Level i a -> f (Level i b) Source # sequenceA :: Applicative f => Level i (f a) -> f (Level i a) Source # mapM :: Monad m => (a -> m b) -> Level i a -> m (Level i b) Source # sequence :: Monad m => Level i (m a) -> m (Level i a) Source #
Functor (Level i) Source #
Instance details Defined in Control.Lens.Internal.Level Methods fmap :: (a -> b) -> Level i a -> Level i b Source # (<$) :: a -> Level i b -> Level i a Source #
(Read i, Read a) => Read (Level i a) Source #
Instance details Defined in Control.Lens.Internal.Level Methods readsPrec :: Int -> ReadS (Level i a) Source # readList :: ReadS [Level i a] Source # readPrec :: ReadPrec (Level i a) Source # readListPrec :: ReadPrec [Level i a] Source #
(Show i, Show a) => Show (Level i a) Source #
Instance details Defined in Control.Lens.Internal.Level Methods showsPrec :: Int -> Level i a -> ShowS Source # show :: Level i a -> String Source # showList :: [Level i a] -> ShowS Source #
(Eq i, Eq a) => Eq (Level i a) Source #
Instance details Defined in Control.Lens.Internal.Level Methods (==) :: Level i a -> Level i a -> Bool Source # (/=) :: Level i a -> Level i a -> Bool Source #
(Ord i, Ord a) => Ord (Level i a) Source #
Instance details Defined in Control.Lens.Internal.Level Methods compare :: Level i a -> Level i a -> Ordering Source # (<) :: Level i a -> Level i a -> Bool Source # (<=) :: Level i a -> Level i a -> Bool Source # (>) :: Level i a -> Level i a -> Bool Source # (>=) :: Level i a -> Level i a -> Bool Source # max :: Level i a -> Level i a -> Level i a Source # min :: Level i a -> Level i a -> Level i a Source #

newtype Indexed i a b Source #

A function with access to a index. This constructor may be useful when you need to store an Indexable in a container to avoid ImpredicativeTypes.

index :: Indexed i a b -> i -> a -> b

Constructors

Indexed
Fields runIndexed :: i -> a -> b

Instances

Instances details

i ~ j => Indexable i (Indexed j) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods indexed :: Indexed j a b -> i -> a -> b Source #
Arrow (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods arr :: (b -> c) -> Indexed i b c Source # first :: Indexed i b c -> Indexed i (b, d) (c, d) Source # second :: Indexed i b c -> Indexed i (d, b) (d, c) Source # (***) :: Indexed i b c -> Indexed i b' c' -> Indexed i (b, b') (c, c') Source # (&&&) :: Indexed i b c -> Indexed i b c' -> Indexed i b (c, c') Source #
ArrowApply (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods app :: Indexed i (Indexed i b c, b) c Source #
ArrowChoice (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods left :: Indexed i b c -> Indexed i (Either b d) (Either c d) Source # right :: Indexed i b c -> Indexed i (Either d b) (Either d c) Source # (+++) :: Indexed i b c -> Indexed i b' c' -> Indexed i (Either b b') (Either c c') Source # (\|\|\|) :: Indexed i b d -> Indexed i c d -> Indexed i (Either b c) d Source #
ArrowLoop (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods loop :: Indexed i (b, d) (c, d) -> Indexed i b c Source #
Conjoined (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b) Source # conjoined :: (Indexed i ~ (->) => q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r Source #
Choice (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods left' :: Indexed i a b -> Indexed i (Either a c) (Either b c) Source # right' :: Indexed i a b -> Indexed i (Either c a) (Either c b) Source #
Closed (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods closed :: Indexed i a b -> Indexed i (x -> a) (x -> b) Source #
Corepresentable (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Associated Types type Corep (Indexed i) :: Type -> Type Source # Methods cotabulate :: (Corep (Indexed i) d -> c) -> Indexed i d c Source #
Representable (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Associated Types type Rep (Indexed i) :: Type -> Type Source # Methods tabulate :: (d -> Rep (Indexed i) c) -> Indexed i d c Source #
Costrong (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods unfirst :: Indexed i (a, d) (b, d) -> Indexed i a b Source # unsecond :: Indexed i (d, a) (d, b) -> Indexed i a b Source #
Strong (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods first' :: Indexed i a b -> Indexed i (a, c) (b, c) Source # second' :: Indexed i a b -> Indexed i (c, a) (c, b) Source #
Profunctor (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods dimap :: (a -> b) -> (c -> d) -> Indexed i b c -> Indexed i a d Source # lmap :: (a -> b) -> Indexed i b c -> Indexed i a c Source # rmap :: (b -> c) -> Indexed i a b -> Indexed i a c Source # (#.) :: forall a b c q. Coercible c b => q b c -> Indexed i a b -> Indexed i a c Source # (.#) :: forall a b c q. Coercible b a => Indexed i b c -> q a b -> Indexed i a c Source #
Bizarre (Indexed Int) Mafic Source #
Instance details Defined in Control.Lens.Internal.Magma Methods bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t Source #
Category (Indexed i :: Type -> Type -> Type) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods id :: forall (a :: k). Indexed i a a Source # (.) :: forall (b :: k) (c :: k) (a :: k). Indexed i b c -> Indexed i a b -> Indexed i a c Source #
Bizarre (Indexed i) (Molten i) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods bazaar :: Applicative f => Indexed i a (f b) -> Molten i a b t -> f t Source #
Sellable (Indexed i) (Molten i) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods sell :: Indexed i a (Molten i a b b) Source #
Cosieve (Indexed i) ((,) i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods cosieve :: Indexed i a b -> (i, a) -> b Source #
Sieve (Indexed i) ((->) i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods sieve :: Indexed i a b -> a -> i -> b Source #
MonadFix (Indexed i a) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods mfix :: (a0 -> Indexed i a a0) -> Indexed i a a0 Source #
Applicative (Indexed i a) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods pure :: a0 -> Indexed i a a0 Source # (<>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b Source # liftA2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c Source # (>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b Source # (<*) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0 Source #
Functor (Indexed i a) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods fmap :: (a0 -> b) -> Indexed i a a0 -> Indexed i a b Source # (<$) :: a0 -> Indexed i a b -> Indexed i a a0 Source #
Monad (Indexed i a) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods (>>=) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b Source # (>>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b Source # return :: a0 -> Indexed i a a0 Source #
Apply (Indexed i a) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods (<.>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b Source # (.>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b Source # (<.) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0 Source # liftF2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c Source #
Bind (Indexed i a) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods (>>-) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b Source # join :: Indexed i a (Indexed i a a0) -> Indexed i a a0 Source #
type Corep (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed type Corep (Indexed i) = (,) i
type Rep (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed type Rep (Indexed i) = (->) i

class Conjoined p => Indexable i p where Source #

This class permits overloading of function application for things that also admit a notion of a key or index.

Methods

indexed :: p a b -> i -> a -> b Source #

Build a function from an indexed function.

Instances

Instances details

i ~ j => Indexable i (Indexed j) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods indexed :: Indexed j a b -> i -> a -> b Source #
Indexable i (->) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods indexed :: (a -> b) -> i -> a -> b Source #

class (Choice p, Corepresentable p, Comonad (Corep p), Traversable (Corep p), Strong p, Representable p, Monad (Rep p), MonadFix (Rep p), Distributive (Rep p), Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined p where Source #

This is a Profunctor that is both Corepresentable by f and Representable by g such that f is left adjoint to g. From this you can derive a lot of structure due to the preservation of limits and colimits.

Minimal complete definition

Nothing

Methods

distrib :: Functor f => p a b -> p (f a) (f b) Source #

Conjoined is strong enough to let us distribute every Conjoined Profunctor over every Haskell Functor. This is effectively a generalization of fmap.

conjoined :: (p ~ (->) => q (a -> b) r) -> q (p a b) r -> q (p a b) r Source #

This permits us to make a decision at an outermost point about whether or not we use an index.

Ideally any use of this function should be done in such a way so that you compute the same answer, but this cannot be enforced at the type level.

Instances

Instances details

Conjoined ReifiedGetter Source #
Instance details Defined in Control.Lens.Reified Methods distrib :: Functor f => ReifiedGetter a b -> ReifiedGetter (f a) (f b) Source # conjoined :: (ReifiedGetter ~ (->) => q (a -> b) r) -> q (ReifiedGetter a b) r -> q (ReifiedGetter a b) r Source #
Conjoined (Indexed i) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b) Source # conjoined :: (Indexed i ~ (->) => q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r Source #
Conjoined (->) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods distrib :: Functor f => (a -> b) -> f a -> f b Source # conjoined :: ((->) ~ (->) => q (a -> b) r) -> q (a -> b) r -> q (a -> b) r Source #

indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t Source #

Transform a Traversal into an IndexedTraversal or a Fold into an IndexedFold, etc.

indexing :: Traversal s t a b -> IndexedTraversal Int s t a b
indexing :: Prism s t a b     -> IndexedTraversal Int s t a b
indexing :: Lens s t a b      -> IndexedLens Int  s t a b
indexing :: Iso s t a b       -> IndexedLens Int s t a b
indexing :: Fold s a          -> IndexedFold Int s a
indexing :: Getter s a        -> IndexedGetter Int s a

indexing :: Indexable Int p => LensLike (Indexing f) s t a b -> Over p f s t a b

indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t Source #

Transform a Traversal into an IndexedTraversal or a Fold into an IndexedFold, etc.

This combinator is like indexing except that it handles large traversals and folds gracefully.

indexing64 :: Traversal s t a b -> IndexedTraversal Int64 s t a b
indexing64 :: Prism s t a b     -> IndexedTraversal Int64 s t a b
indexing64 :: Lens s t a b      -> IndexedLens Int64 s t a b
indexing64 :: Iso s t a b       -> IndexedLens Int64 s t a b
indexing64 :: Fold s a          -> IndexedFold Int64 s a
indexing64 :: Getter s a        -> IndexedGetter Int64 s a

indexing64 :: Indexable Int64 p => LensLike (Indexing64 f) s t a b -> Over p f s t a b

withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t) Source #

Fold a container with indices returning both the indices and the values.

The result is only valid to compose in a Traversal, if you don't edit the index as edits to the index have no effect.

>>> [10, 20, 30] ^.. ifolded . withIndex
[(0,10),(1,20),(2,30)]

>>> [10, 20, 30] ^.. ifolded . withIndex . alongside negated (re _Show)
[(0,"10"),(-1,"20"),(-2,"30")]

asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s) Source #

When composed with an IndexedFold or IndexedTraversal this yields an (Indexed) Fold of the indices.

data Rightmost a Source #

Used for lastOf.

Instances

Instances details

Monoid (Rightmost a) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Rightmost a Source # mappend :: Rightmost a -> Rightmost a -> Rightmost a Source # mconcat :: [Rightmost a] -> Rightmost a Source #
Semigroup (Rightmost a) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Rightmost a -> Rightmost a -> Rightmost a Source # sconcat :: NonEmpty (Rightmost a) -> Rightmost a Source # stimes :: Integral b => b -> Rightmost a -> Rightmost a Source #

data Leftmost a Source #

Used for firstOf.

Instances

Instances details

Monoid (Leftmost a) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Leftmost a Source # mappend :: Leftmost a -> Leftmost a -> Leftmost a Source # mconcat :: [Leftmost a] -> Leftmost a Source #
Semigroup (Leftmost a) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Leftmost a -> Leftmost a -> Leftmost a Source # sconcat :: NonEmpty (Leftmost a) -> Leftmost a Source # stimes :: Integral b => b -> Leftmost a -> Leftmost a Source #

data Sequenced a m Source #

Used internally by mapM_ and the like.

The argument a of the result should not be used!

See 4.16 Changelog entry for the explanation of "why not Apply f =>"?

Instances

Instances details

Monad m => Monoid (Sequenced a m) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Sequenced a m Source # mappend :: Sequenced a m -> Sequenced a m -> Sequenced a m Source # mconcat :: [Sequenced a m] -> Sequenced a m Source #
Monad m => Semigroup (Sequenced a m) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Sequenced a m -> Sequenced a m -> Sequenced a m Source # sconcat :: NonEmpty (Sequenced a m) -> Sequenced a m Source # stimes :: Integral b => b -> Sequenced a m -> Sequenced a m Source #

data Traversed a f Source #

Used internally by traverseOf_ and the like.

The argument a of the result should not be used!

Instances

Instances details

Applicative f => Monoid (Traversed a f) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods mempty :: Traversed a f Source # mappend :: Traversed a f -> Traversed a f -> Traversed a f Source # mconcat :: [Traversed a f] -> Traversed a f Source #
Applicative f => Semigroup (Traversed a f) Source #
Instance details Defined in Control.Lens.Internal.Fold Methods (<>) :: Traversed a f -> Traversed a f -> Traversed a f Source # sconcat :: NonEmpty (Traversed a f) -> Traversed a f Source # stimes :: Integral b => b -> Traversed a f -> Traversed a f Source #

type Context' a = Context a a Source #

type Context' a s = Context a a s

data Context a b t Source #

The indexed store can be used to characterize a Lens and is used by cloneLens.

Context a b t is isomorphic to newtype Context a b t = Context { runContext :: forall f. Functor f => (a -> f b) -> f t }, and to exists s. (s, Lens s t a b).

A Context is like a Lens that has already been applied to a some structure.

Constructors

Context (b -> t) a

Instances

Instances details

IndexedComonad Context Source #
Instance details Defined in Control.Lens.Internal.Context Methods iextract :: Context a a t -> t Source # iduplicate :: Context a c t -> Context a b (Context b c t) Source # iextend :: (Context b c t -> r) -> Context a c t -> Context a b r Source #
IndexedComonadStore Context Source #
Instance details Defined in Control.Lens.Internal.Context Methods ipos :: Context a c t -> a Source # ipeek :: c -> Context a c t -> t Source # ipeeks :: (a -> c) -> Context a c t -> t Source # iseek :: b -> Context a c t -> Context b c t Source # iseeks :: (a -> b) -> Context a c t -> Context b c t Source # iexperiment :: Functor f => (b -> f c) -> Context b c t -> f t Source # context :: Context a b t -> Context a b t Source #
IndexedFunctor Context Source #
Instance details Defined in Control.Lens.Internal.Context Methods ifmap :: (s -> t) -> Context a b s -> Context a b t Source #
a ~ b => ComonadStore a (Context a b) Source #
Instance details Defined in Control.Lens.Internal.Context Methods pos :: Context a b a0 -> a Source # peek :: a -> Context a b a0 -> a0 Source # peeks :: (a -> a) -> Context a b a0 -> a0 Source # seek :: a -> Context a b a0 -> Context a b a0 Source # seeks :: (a -> a) -> Context a b a0 -> Context a b a0 Source # experiment :: Functor f => (a -> f a) -> Context a b a0 -> f a0 Source #
Functor (Context a b) Source #
Instance details Defined in Control.Lens.Internal.Context Methods fmap :: (a0 -> b0) -> Context a b a0 -> Context a b b0 Source # (<$) :: a0 -> Context a b b0 -> Context a b a0 Source #
a ~ b => Comonad (Context a b) Source #
Instance details Defined in Control.Lens.Internal.Context Methods extract :: Context a b a0 -> a0 Source # duplicate :: Context a b a0 -> Context a b (Context a b a0) Source # extend :: (Context a b a0 -> b0) -> Context a b a0 -> Context a b b0 Source #
Sellable (->) Context Source #
Instance details Defined in Control.Lens.Internal.Context Methods sell :: a -> Context a b b Source #

type Bazaar1' p a = Bazaar1 p a a Source #

This alias is helpful when it comes to reducing repetition in type signatures.

type Bazaar1' p a t = Bazaar1 p a a t

newtype Bazaar1 p a b t Source #

This is used to characterize a Traversal.

a.k.a. indexed Cartesian store comonad, indexed Kleene store comonad, or an indexed FunList.

http://twanvl.nl/blog/haskell/non-regular1

A Bazaar1 is like a Traversal that has already been applied to some structure.

Where a Context a b t holds an a and a function from b to t, a Bazaar1 a b t holds N as and a function from N bs to t, (where N might be infinite).

Mnemonically, a Bazaar1 holds many stores and you can easily add more.

This is a final encoding of Bazaar1.

Constructors

Bazaar1
Fields runBazaar1 :: forall f. Apply f => p a (f b) -> f t

Instances

Instances details

Profunctor p => Bizarre1 p (Bazaar1 p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods bazaar1 :: Apply f => p a (f b) -> Bazaar1 p a b t -> f t Source #
Corepresentable p => Sellable p (Bazaar1 p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods sell :: p a (Bazaar1 p a b b) Source #
Conjoined p => IndexedComonad (Bazaar1 p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods iextract :: Bazaar1 p a a t -> t Source # iduplicate :: Bazaar1 p a c t -> Bazaar1 p a b (Bazaar1 p b c t) Source # iextend :: (Bazaar1 p b c t -> r) -> Bazaar1 p a c t -> Bazaar1 p a b r Source #
IndexedFunctor (Bazaar1 p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods ifmap :: (s -> t) -> Bazaar1 p a b s -> Bazaar1 p a b t Source #
Functor (Bazaar1 p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods fmap :: (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 Source # (<$) :: a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0 Source #
(a ~ b, Conjoined p) => Comonad (Bazaar1 p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods extract :: Bazaar1 p a b a0 -> a0 Source # duplicate :: Bazaar1 p a b a0 -> Bazaar1 p a b (Bazaar1 p a b a0) Source # extend :: (Bazaar1 p a b a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 Source #
(a ~ b, Conjoined p) => ComonadApply (Bazaar1 p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<@>) :: Bazaar1 p a b (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 Source # (@>) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b b0 Source # (<@) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0 Source #
Apply (Bazaar1 p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<.>) :: Bazaar1 p a b (a0 -> b0) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 Source # (.>) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b b0 Source # (<.) :: Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b a0 Source # liftF2 :: (a0 -> b0 -> c) -> Bazaar1 p a b a0 -> Bazaar1 p a b b0 -> Bazaar1 p a b c Source #

type Bazaar' p a = Bazaar p a a Source #

This alias is helpful when it comes to reducing repetition in type signatures.

type Bazaar' p a t = Bazaar p a a t

newtype Bazaar p a b t Source #

This is used to characterize a Traversal.

a.k.a. indexed Cartesian store comonad, indexed Kleene store comonad, or an indexed FunList.

http://twanvl.nl/blog/haskell/non-regular1

A Bazaar is like a Traversal that has already been applied to some structure.

Where a Context a b t holds an a and a function from b to t, a Bazaar a b t holds N as and a function from N bs to t, (where N might be infinite).

Mnemonically, a Bazaar holds many stores and you can easily add more.

This is a final encoding of Bazaar.

Constructors

Bazaar
Fields runBazaar :: forall f. Applicative f => p a (f b) -> f t

Instances

Instances details

Profunctor p => Bizarre p (Bazaar p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods bazaar :: Applicative f => p a (f b) -> Bazaar p a b t -> f t Source #
Corepresentable p => Sellable p (Bazaar p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods sell :: p a (Bazaar p a b b) Source #
Conjoined p => IndexedComonad (Bazaar p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods iextract :: Bazaar p a a t -> t Source # iduplicate :: Bazaar p a c t -> Bazaar p a b (Bazaar p b c t) Source # iextend :: (Bazaar p b c t -> r) -> Bazaar p a c t -> Bazaar p a b r Source #
IndexedFunctor (Bazaar p) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods ifmap :: (s -> t) -> Bazaar p a b s -> Bazaar p a b t Source #
Applicative (Bazaar p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods pure :: a0 -> Bazaar p a b a0 Source # (<>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b c Source # (>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0 Source # (<*) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0 Source #
Functor (Bazaar p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods fmap :: (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 Source # (<$) :: a0 -> Bazaar p a b b0 -> Bazaar p a b a0 Source #
(a ~ b, Conjoined p) => Comonad (Bazaar p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods extract :: Bazaar p a b a0 -> a0 Source # duplicate :: Bazaar p a b a0 -> Bazaar p a b (Bazaar p a b a0) Source # extend :: (Bazaar p a b a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 Source #
(a ~ b, Conjoined p) => ComonadApply (Bazaar p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<@>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 Source # (@>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0 Source # (<@) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0 Source #
Apply (Bazaar p a b) Source #
Instance details Defined in Control.Lens.Internal.Bazaar Methods (<.>) :: Bazaar p a b (a0 -> b0) -> Bazaar p a b a0 -> Bazaar p a b b0 Source # (.>) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b b0 Source # (<.) :: Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b a0 Source # liftF2 :: (a0 -> b0 -> c) -> Bazaar p a b a0 -> Bazaar p a b b0 -> Bazaar p a b c Source #

data Magma i t b a Source #

This provides a way to peek at the internal structure of a Traversal or IndexedTraversal

Instances

Instances details

FoldableWithIndex i (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods ifoldMap :: Monoid m => (i -> a -> m) -> Magma i t b a -> m Source # ifoldMap' :: Monoid m => (i -> a -> m) -> Magma i t b a -> m Source # ifoldr :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 Source # ifoldl :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 Source # ifoldr' :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 Source # ifoldl' :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 Source #
FunctorWithIndex i (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods imap :: (i -> a -> b0) -> Magma i t b a -> Magma i t b b0 Source #
TraversableWithIndex i (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods itraverse :: Applicative f => (i -> a -> f b0) -> Magma i t b a -> f (Magma i t b b0) Source #
Foldable (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods fold :: Monoid m => Magma i t b m -> m Source # foldMap :: Monoid m => (a -> m) -> Magma i t b a -> m Source # foldMap' :: Monoid m => (a -> m) -> Magma i t b a -> m Source # foldr :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 Source # foldr' :: (a -> b0 -> b0) -> b0 -> Magma i t b a -> b0 Source # foldl :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 Source # foldl' :: (b0 -> a -> b0) -> b0 -> Magma i t b a -> b0 Source # foldr1 :: (a -> a -> a) -> Magma i t b a -> a Source # foldl1 :: (a -> a -> a) -> Magma i t b a -> a Source # toList :: Magma i t b a -> [a] Source # null :: Magma i t b a -> Bool Source # length :: Magma i t b a -> Int Source # elem :: Eq a => a -> Magma i t b a -> Bool Source # maximum :: Ord a => Magma i t b a -> a Source # minimum :: Ord a => Magma i t b a -> a Source # sum :: Num a => Magma i t b a -> a Source # product :: Num a => Magma i t b a -> a Source #
Traversable (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods traverse :: Applicative f => (a -> f b0) -> Magma i t b a -> f (Magma i t b b0) Source # sequenceA :: Applicative f => Magma i t b (f a) -> f (Magma i t b a) Source # mapM :: Monad m => (a -> m b0) -> Magma i t b a -> m (Magma i t b b0) Source # sequence :: Monad m => Magma i t b (m a) -> m (Magma i t b a) Source #
Functor (Magma i t b) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods fmap :: (a -> b0) -> Magma i t b a -> Magma i t b b0 Source # (<$) :: a -> Magma i t b b0 -> Magma i t b a Source #
(Show i, Show a) => Show (Magma i t b a) Source #
Instance details Defined in Control.Lens.Internal.Magma Methods showsPrec :: Int -> Magma i t b a -> ShowS Source # show :: Magma i t b a -> String Source # showList :: [Magma i t b a] -> ShowS Source #

class (Profunctor p, Bifunctor p) => Reviewable p Source #

This class is provided mostly for backwards compatibility with lens 3.8, but it can also shorten type signatures.

Instances

Instances details

(Profunctor p, Bifunctor p) => Reviewable p Source #
Instance details Defined in Control.Lens.Internal.Review

retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b Source #

This is a profunctor used internally to implement Review

It plays a role similar to that of Accessor or Const do for Control.Lens.Getter

class (Applicative f, Distributive f, Traversable f) => Settable f Source #

Anything Settable must be isomorphic to the Identity Functor.

Minimal complete definition

untainted

Instances

Instances details

Settable Identity Source #	So you can pass our `Setter` into combinators from other lens libraries.
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Identity a -> a Source # untaintedDot :: Profunctor p => p a (Identity b) -> p a b Source # taintedDot :: Profunctor p => p a b -> p a (Identity b) Source #
Settable f => Settable (Backwards f) Source #	`backwards`
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Backwards f a -> a Source # untaintedDot :: Profunctor p => p a (Backwards f b) -> p a b Source # taintedDot :: Profunctor p => p a b -> p a (Backwards f b) Source #
(Settable f, Settable g) => Settable (Compose f g) Source #
Instance details Defined in Control.Lens.Internal.Setter Methods untainted :: Compose f g a -> a Source # untaintedDot :: Profunctor p => p a (Compose f g b) -> p a b Source # taintedDot :: Profunctor p => p a b -> p a (Compose f g b) Source #

type Over' p f s a = Over p f s s a a Source #

This is a convenient alias for use when you need to consume either indexed or non-indexed lens-likes based on context.

type Over' p f = Simple (Over p f)

type Over p f s t a b = p a (f b) -> s -> f t Source #

This is a convenient alias for use when you need to consume either indexed or non-indexed lens-likes based on context.

type IndexedLensLike' i f s a = IndexedLensLike i f s s a a Source #

Convenient alias for constructing simple indexed lenses and their ilk.

type IndexedLensLike i f s t a b = forall p. Indexable i p => p a (f b) -> s -> f t Source #

Convenient alias for constructing indexed lenses and their ilk.

type LensLike' f s a = LensLike f s s a a Source #

type LensLike' f = Simple (LensLike f)

type LensLike f s t a b = (a -> f b) -> s -> f t Source #

Many combinators that accept a Lens can also accept a Traversal in limited situations.

They do so by specializing the type of Functor that they require of the caller.

If a function accepts a LensLike f s t a b for some Functor f, then they may be passed a Lens.

Further, if f is an Applicative, they may also be passed a Traversal.

type Optical' p q f s a = Optical p q f s s a a Source #

type Optical' p q f s a = Simple (Optical p q f) s a

type Optical p q f s t a b = p a (f b) -> q s (f t) Source #

type LensLike f s t a b = Optical (->) (->) f s t a b

type Over p f s t a b = Optical p (->) f s t a b

type Optic p f s t a b = Optical p p f s t a b

type Optic' p f s a = Optic p f s s a a Source #

type Optic' p f s a = Simple (Optic p f) s a

type Optic p f s t a b = p a (f b) -> p s (f t) Source #

A valid Optic l should satisfy the laws:

l pure ≡ pure
l (Procompose f g) = Procompose (l f) (l g)

This gives rise to the laws for Equality, Iso, Prism, Lens, Traversal, Traversal1, Setter, Fold, Fold1, and Getter as well along with their index-preserving variants.

type LensLike f s t a b = Optic (->) f s t a b

type Simple f s a = f s s a a Source #

A Simple Lens, Simple Traversal, ... can be used instead of a Lens,Traversal, ... whenever the type variables don't change upon setting a value.

_imagPart :: Simple Lens (Complex a) a
traversed :: Simple (IndexedTraversal Int) [a] a

Note: To use this alias in your own code with LensLike f or Setter, you may have to turn on LiberalTypeSynonyms.

This is commonly abbreviated as a "prime" marker, e.g. Lens' = Simple Lens.

type IndexPreservingFold1 s a = forall p f. (Conjoined p, Contravariant f, Apply f) => p a (f a) -> p s (f s) Source #

type IndexedFold1 i s a = forall p f. (Indexable i p, Contravariant f, Apply f) => p a (f a) -> s -> f s Source #

type Fold1 s a = forall f. (Contravariant f, Apply f) => (a -> f a) -> s -> f s Source #

A relevant Fold (aka Fold1) has one or more targets.

type IndexPreservingFold s a = forall p f. (Conjoined p, Contravariant f, Applicative f) => p a (f a) -> p s (f s) Source #

An IndexPreservingFold can be used as a Fold, but when composed with an IndexedTraversal, IndexedFold, or IndexedLens yields an IndexedFold respectively.

type IndexedFold i s a = forall p f. (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> s -> f s Source #

Every IndexedFold is a valid Fold and can be used for Getting.

type Fold s a = forall f. (Contravariant f, Applicative f) => (a -> f a) -> s -> f s Source #

A Fold describes how to retrieve multiple values in a way that can be composed with other LensLike constructions.

A Fold s a provides a structure with operations very similar to those of the Foldable typeclass, see foldMapOf and the other Fold combinators.

By convention, if there exists a foo method that expects a Foldable (f a), then there should be a fooOf method that takes a Fold s a and a value of type s.

A Getter is a legal Fold that just ignores the supplied Monoid.

Unlike a Traversal a Fold is read-only. Since a Fold cannot be used to write back there are no Lens laws that apply.

type IndexPreservingGetter s a = forall p f. (Conjoined p, Contravariant f, Functor f) => p a (f a) -> p s (f s) Source #

An IndexPreservingGetter can be used as a Getter, but when composed with an IndexedTraversal, IndexedFold, or IndexedLens yields an IndexedFold, IndexedFold or IndexedGetter respectively.

type IndexedGetter i s a = forall p f. (Indexable i p, Contravariant f, Functor f) => p a (f a) -> s -> f s Source #

Every IndexedGetter is a valid IndexedFold and can be used for Getting like a Getter.

type Getter s a = forall f. (Contravariant f, Functor f) => (a -> f a) -> s -> f s Source #

A Getter describes how to retrieve a single value in a way that can be composed with other LensLike constructions.

Unlike a Lens a Getter is read-only. Since a Getter cannot be used to write back there are no Lens laws that can be applied to it. In fact, it is isomorphic to an arbitrary function from (s -> a).

Moreover, a Getter can be used directly as a Fold, since it just ignores the Applicative.

type As a = Equality' a a Source #

Composable asTypeOf. Useful for constraining excess polymorphism, foo . (id :: As Int) . bar.

type Equality' s a = Equality s s a a Source #

A Simple Equality.

type Equality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = forall k3 (p :: k1 -> k3 -> Type) (f :: k2 -> k3). p a (f b) -> p s (f t) Source #

A witness that (a ~ s, b ~ t).

Note: Composition with an Equality is index-preserving.

type Prism' s a = Prism s s a a Source #

A Simple Prism.

type Prism s t a b = forall p f. (Choice p, Applicative f) => p a (f b) -> p s (f t) Source #

A Prism l is a Traversal that can also be turned around with re to obtain a Getter in the opposite direction.

There are three laws that a Prism should satisfy:

First, if I re or review a value with a Prism and then preview or use (^?), I will get it back:

preview l (review l b) ≡ Just b

Second, if you can extract a value a using a Prism l from a value s, then the value s is completely described by l and a:

preview l s ≡ Just a ⟹ review l a ≡ s

Third, if you get non-match t, you can convert it result back to s:

matching l s ≡ Left t ⟹ matching l t ≡ Left s

The first two laws imply that the Traversal laws hold for every Prism and that we traverse at most 1 element:

lengthOf l x <= 1

It may help to think of this as an Iso that can be partial in one direction.

Every Prism is a valid Traversal.

Every Iso is a valid Prism.

For example, you might have a Prism' Integer Natural allows you to always go from a Natural to an Integer, and provide you with tools to check if an Integer is a Natural and/or to edit one if it is.

nat :: Prism' Integer Natural
nat = prism toInteger $ \ i ->
   if i < 0
   then Left i
   else Right (fromInteger i)

Now we can ask if an Integer is a Natural.

>>> 5^?nat
Just 5

>>> (-5)^?nat
Nothing

We can update the ones that are:

>>> (-3,4) & both.nat *~ 2
(-3,8)

And we can then convert from a Natural to an Integer.

>>> 5 ^. re nat -- :: Natural
5

Similarly we can use a Prism to traverse the Left half of an Either:

>>> Left "hello" & _Left %~ length
Left 5

or to construct an Either:

>>> 5^.re _Left
Left 5

such that if you query it with the Prism, you will get your original input back.

>>> 5^.re _Left ^? _Left
Just 5

Another interesting way to think of a Prism is as the categorical dual of a Lens -- a co-Lens, so to speak. This is what permits the construction of outside.

Note: Composition with a Prism is index-preserving.

type AReview t b = Optic' Tagged Identity t b Source #

If you see this in a signature for a function, the function is expecting a Review (in practice, this usually means a Prism).

type Review t b = forall p f. (Choice p, Bifunctor p, Settable f) => Optic' p f t b Source #

This is a limited form of a Prism that can only be used for re operations.

Like with a Getter, there are no laws to state for a Review.

You can generate a Review by using unto. You can also use any Prism or Iso directly as a Review.

type Iso' s a = Iso s s a a Source #

type Iso' = Simple Iso

type Iso s t a b = forall p f. (Profunctor p, Functor f) => p a (f b) -> p s (f t) Source #

Isomorphism families can be composed with another Lens using (.) and id.

Since every Iso is both a valid Lens and a valid Prism, the laws for those types imply the following laws for an Iso f:

f . from f ≡ id
from f . f ≡ id

Note: Composition with an Iso is index- and measure- preserving.

type IndexPreservingSetter' s a = IndexPreservingSetter s s a a Source #

type IndexedPreservingSetter' i = Simple IndexedPreservingSetter

type IndexPreservingSetter s t a b = forall p f. (Conjoined p, Settable f) => p a (f b) -> p s (f t) Source #

An IndexPreservingSetter can be composed with a IndexedSetter, IndexedTraversal or IndexedLens and leaves the index intact, yielding an IndexedSetter.

type IndexedSetter' i s a = IndexedSetter i s s a a Source #

type IndexedSetter' i = Simple (IndexedSetter i)

type IndexedSetter i s t a b = forall f p. (Indexable i p, Settable f) => p a (f b) -> s -> f t Source #

Every IndexedSetter is a valid Setter.

The Setter laws are still required to hold.

type Setter' s a = Setter s s a a Source #

A Setter' is just a Setter that doesn't change the types.

These are particularly common when talking about monomorphic containers. e.g.

sets Data.Text.map :: Setter' Text Char

type Setter' = Simple Setter

type Setter s t a b = forall f. Settable f => (a -> f b) -> s -> f t Source #

The only LensLike law that can apply to a Setter l is that

set l y (set l x a) ≡ set l y a

You can't view a Setter in general, so the other two laws are irrelevant.

However, two Functor laws apply to a Setter:

over l id ≡ id
over l f . over l g ≡ over l (f . g)

These can be stated more directly:

l pure ≡ pure
l f . untainted . l g ≡ l (f . untainted . g)

You can compose a Setter with a Lens or a Traversal using (.) from the Prelude and the result is always only a Setter and nothing more.

>>> over traverse f [a,b,c,d]
[f a,f b,f c,f d]

>>> over _1 f (a,b)
(f a,b)

>>> over (traverse._1) f [(a,b),(c,d)]
[(f a,b),(f c,d)]

>>> over both f (a,b)
(f a,f b)

>>> over (traverse.both) f [(a,b),(c,d)]
[(f a,f b),(f c,f d)]

type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a Source #

type IndexPreservingTraversal1 s t a b = forall p f. (Conjoined p, Apply f) => p a (f b) -> p s (f t) Source #

type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a Source #

type IndexPreservingTraversal' = Simple IndexPreservingTraversal

type IndexPreservingTraversal s t a b = forall p f. (Conjoined p, Applicative f) => p a (f b) -> p s (f t) Source #

An IndexPreservingLens leaves any index it is composed with alone.

type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a Source #

type IndexedTraversal1 i s t a b = forall p f. (Indexable i p, Apply f) => p a (f b) -> s -> f t Source #

type IndexedTraversal' i s a = IndexedTraversal i s s a a Source #

type IndexedTraversal' i = Simple (IndexedTraversal i)

type IndexedTraversal i s t a b = forall p f. (Indexable i p, Applicative f) => p a (f b) -> s -> f t Source #

Every IndexedTraversal is a valid Traversal or IndexedFold.

The Indexed constraint is used to allow an IndexedTraversal to be used directly as a Traversal.

The Traversal laws are still required to hold.

In addition, the index i should satisfy the requirement that it stays unchanged even when modifying the value a, otherwise traversals like indices break the Traversal laws.

type Traversal1' s a = Traversal1 s s a a Source #

type Traversal1 s t a b = forall f. Apply f => (a -> f b) -> s -> f t Source #

type Traversal' s a = Traversal s s a a Source #

type Traversal' = Simple Traversal

type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t Source #

A Traversal can be used directly as a Setter or a Fold (but not as a Lens) and provides the ability to both read and update multiple fields, subject to some relatively weak Traversal laws.

These have also been known as multilenses, but they have the signature and spirit of

traverse :: Traversable f => Traversal (f a) (f b) a b

and the more evocative name suggests their application.

Most of the time the Traversal you will want to use is just traverse, but you can also pass any Lens or Iso as a Traversal, and composition of a Traversal (or Lens or Iso) with a Traversal (or Lens or Iso) using (.) forms a valid Traversal.

The laws for a Traversal t follow from the laws for Traversable as stated in "The Essence of the Iterator Pattern".

t pure ≡ pure
fmap (t f) . t g ≡ getCompose . t (Compose . fmap f . g)

One consequence of this requirement is that a Traversal needs to leave the same number of elements as a candidate for subsequent Traversal that it started with. Another testament to the strength of these laws is that the caveat expressed in section 5.5 of the "Essence of the Iterator Pattern" about exotic Traversable instances that traverse the same entry multiple times was actually already ruled out by the second law in that same paper!

type IndexPreservingLens' s a = IndexPreservingLens s s a a Source #

type IndexPreservingLens' = Simple IndexPreservingLens

type IndexPreservingLens s t a b = forall p f. (Conjoined p, Functor f) => p a (f b) -> p s (f t) Source #

An IndexPreservingLens leaves any index it is composed with alone.

type IndexedLens' i s a = IndexedLens i s s a a Source #

type IndexedLens' i = Simple (IndexedLens i)

type IndexedLens i s t a b = forall f p. (Indexable i p, Functor f) => p a (f b) -> s -> f t Source #

Every IndexedLens is a valid Lens and a valid IndexedTraversal.

type Lens' s a = Lens s s a a Source #

type Lens' = Simple Lens

type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t Source #

A Lens is actually a lens family as described in http://comonad.com/reader/2012/mirrored-lenses/.

With great power comes great responsibility and a Lens is subject to the three common sense Lens laws:

1) You get back what you put in:

view l (set l v s)  ≡ v

2) Putting back what you got doesn't change anything:

set l (view l s) s  ≡ s

3) Setting twice is the same as setting once:

set l v' (set l v s) ≡ set l v' s

These laws are strong enough that the 4 type parameters of a Lens cannot vary fully independently. For more on how they interact, read the "Why is it a Lens Family?" section of http://comonad.com/reader/2012/mirrored-lenses/.

There are some emergent properties of these laws:

1) set l s must be injective for every s This is a consequence of law #1

2) set l must be surjective, because of law #2, which indicates that it is possible to obtain any v from some s such that set s v = s

3) Given just the first two laws you can prove a weaker form of law #3 where the values v that you are setting match:

set l v (set l v s) ≡ set l v s

Every Lens can be used directly as a Setter or Traversal.

You can also use a Lens for Getting as if it were a Fold or Getter.

Since every Lens is a valid Traversal, the Traversal laws are required of any Lens you create:

l pure ≡ pure
fmap (l f) . l g ≡ getCompose . l (Compose . fmap f . g)

type Lens s t a b = forall f. Functor f => LensLike f s t a b

type Setting' p s a = Setting p s s a a Source #

This is a convenient alias when defining highly polymorphic code that takes both ASetter' and AnIndexedSetter' as appropriate. If a function takes this it is expecting one of those two things based on context.

type Setting p s t a b = p a (Identity b) -> s -> Identity t Source #

This is a convenient alias when defining highly polymorphic code that takes both ASetter and AnIndexedSetter as appropriate. If a function takes this it is expecting one of those two things based on context.

type AnIndexedSetter' i s a = AnIndexedSetter i s s a a Source #

type AnIndexedSetter' i = Simple (AnIndexedSetter i)

type AnIndexedSetter i s t a b = Indexed i a (Identity b) -> s -> Identity t Source #

Running an IndexedSetter instantiates it to a concrete type.

When consuming a setter directly to perform a mapping, you can use this type, but most user code will not need to use this type.

type ASetter' s a = ASetter s s a a Source #

This is a useful alias for use when consuming a Setter'.

Most user code will never have to use this type.

type ASetter' = Simple ASetter

type ASetter s t a b = (a -> Identity b) -> s -> Identity t Source #

Running a Setter instantiates it to a concrete type.

When consuming a setter directly to perform a mapping, you can use this type, but most user code will not need to use this type.

mapped :: Functor f => Setter (f a) (f b) a b Source #

This Setter can be used to map over all of the values in a Functor.

fmap ≡ over mapped
fmapDefault ≡ over traverse
(<$) ≡ set mapped

>>> over mapped f [a,b,c]
[f a,f b,f c]

>>> over mapped (+1) [1,2,3]
[2,3,4]

>>> set mapped x [a,b,c]
[x,x,x]

>>> [[a,b],[c]] & mapped.mapped +~ x
[[a + x,b + x],[c + x]]

>>> over (mapped._2) length [("hello","world"),("leaders","!!!")]
[("hello",5),("leaders",3)]

mapped :: Functor f => Setter (f a) (f b) a b

If you want an IndexPreservingSetter use setting fmap.

lifted :: Monad m => Setter (m a) (m b) a b Source #

This setter can be used to modify all of the values in a Monad.

You sometimes have to use this rather than mapped -- due to temporary insanity Functor was not a superclass of Monad until GHC 7.10.

liftM ≡ over lifted

>>> over lifted f [a,b,c]
[f a,f b,f c]

>>> set lifted b (Just a)
Just b

If you want an IndexPreservingSetter use setting liftM.

contramapped :: Contravariant f => Setter (f b) (f a) a b Source #

This Setter can be used to map over all of the inputs to a Contravariant.

contramap ≡ over contramapped

>>> getPredicate (over contramapped (*2) (Predicate even)) 5
True

>>> getOp (over contramapped (*5) (Op show)) 100
"500"

>>> Prelude.map ($ 1) $ over (mapped . _Unwrapping' Op . contramapped) (*12) [(*2),(+1),(^3)]
[24,13,1728]

argument :: Profunctor p => Setter (p b r) (p a r) a b Source #

This Setter can be used to map over the input of a Profunctor.

The most common Profunctor to use this with is (->).

>>> (argument %~ f) g x
g (f x)

>>> (argument %~ show) length [1,2,3]
7

>>> (argument %~ f) h x y
h (f x) y

Map over the argument of the result of a function -- i.e., its second argument:

>>> (mapped.argument %~ f) h x y
h x (f y)

argument :: Setter (b -> r) (a -> r) a b

setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b Source #

Build an index-preserving Setter from a map-like function.

Your supplied function f is required to satisfy:

f id ≡ id
f g . f h ≡ f (g . h)

Equational reasoning:

setting . over ≡ id
over . setting ≡ id

Another way to view sets is that it takes a "semantic editor combinator" and transforms it into a Setter.

setting :: ((a -> b) -> s -> t) -> Setter s t a b

sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b Source #

Build a Setter, IndexedSetter or IndexPreservingSetter depending on your choice of Profunctor.

sets :: ((a -> b) -> s -> t) -> Setter s t a b

cloneSetter :: ASetter s t a b -> Setter s t a b Source #

Restore ASetter to a full Setter.

cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b Source #

Build an IndexPreservingSetter from any Setter.

cloneIndexedSetter :: AnIndexedSetter i s t a b -> IndexedSetter i s t a b Source #

Clone an IndexedSetter.

over :: ASetter s t a b -> (a -> b) -> s -> t Source #

Modify the target of a Lens or all the targets of a Setter or Traversal with a function.

fmap ≡ over mapped
fmapDefault ≡ over traverse
sets . over ≡ id
over . sets ≡ id

Given any valid Setter l, you can also rely on the law:

over l f . over l g = over l (f . g)

e.g.

>>> over mapped f (over mapped g [a,b,c]) == over mapped (f . g) [a,b,c]
True

Another way to view over is to say that it transforms a Setter into a "semantic editor combinator".

>>> over mapped f (Just a)
Just (f a)

>>> over mapped (*10) [1,2,3]
[10,20,30]

>>> over _1 f (a,b)
(f a,b)

>>> over _1 show (10,20)
("10",20)

over :: Setter s t a b -> (a -> b) -> s -> t
over :: ASetter s t a b -> (a -> b) -> s -> t

set :: ASetter s t a b -> b -> s -> t Source #

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

(<$) ≡ set mapped

>>> set _2 "hello" (1,())
(1,"hello")

>>> set mapped () [1,2,3,4]
[(),(),(),()]

Note: Attempting to set a Fold or Getter will fail at compile time with an relatively nice error message.

set :: Setter s t a b    -> b -> s -> t
set :: Iso s t a b       -> b -> s -> t
set :: Lens s t a b      -> b -> s -> t
set :: Traversal s t a b -> b -> s -> t

set' :: ASetter' s a -> a -> s -> s Source #

Replace the target of a Lens or all of the targets of a Setter' or Traversal with a constant value, without changing its type.

This is a type restricted version of set, which retains the type of the original.

>>> set' mapped x [a,b,c,d]
[x,x,x,x]

>>> set' _2 "hello" (1,"world")
(1,"hello")

>>> set' mapped 0 [1,2,3,4]
[0,0,0,0]

Note: Attempting to adjust set' a Fold or Getter will fail at compile time with an relatively nice error message.

set' :: Setter' s a    -> a -> s -> s
set' :: Iso' s a       -> a -> s -> s
set' :: Lens' s a      -> a -> s -> s
set' :: Traversal' s a -> a -> s -> s

assign :: MonadState s m => ASetter s s a b -> b -> m () Source #

Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with a new value, irrespective of the old.

This is an alias for (.=).

>>> execState (do assign _1 c; assign _2 d) (a,b)
(c,d)

>>> execState (both .= c) (a,b)
(c,c)

assign :: MonadState s m => Iso' s a       -> a -> m ()
assign :: MonadState s m => Lens' s a      -> a -> m ()
assign :: MonadState s m => Traversal' s a -> a -> m ()
assign :: MonadState s m => Setter' s a    -> a -> m ()

modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m () Source #

This is an alias for (%=).

scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m () Source #

Write to a fragment of a larger Writer format.

passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a Source #

This is a generalization of pass that allows you to modify just a portion of the resulting MonadWriter.

ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a Source #

This is a generalization of pass that allows you to modify just a portion of the resulting MonadWriter with access to the index of an IndexedSetter.

censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a Source #

This is a generalization of censor that allows you to censor just a portion of the resulting MonadWriter.

icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a Source #

This is a generalization of censor that allows you to censor just a portion of the resulting MonadWriter, with access to the index of an IndexedSetter.

locally :: MonadReader s m => ASetter s s a b -> (a -> b) -> m r -> m r Source #

Modify the value of the Reader environment associated with the target of a Setter, Lens, or Traversal.

locally l id a ≡ a
locally l f . locally l g ≡ locally l (f . g)

>>> (1,1) & locally _1 (+1) (uncurry (+))
3

>>> "," & locally ($) ("Hello" <>) (<> " world!")
"Hello, world!"

locally :: MonadReader s m => Iso s s a b       -> (a -> b) -> m r -> m r
locally :: MonadReader s m => Lens s s a b      -> (a -> b) -> m r -> m r
locally :: MonadReader s m => Traversal s s a b -> (a -> b) -> m r -> m r
locally :: MonadReader s m => Setter s s a b    -> (a -> b) -> m r -> m r

ilocally :: MonadReader s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m r -> m r Source #

This is a generalization of locally that allows one to make indexed local changes to a Reader environment associated with the target of a Setter, Lens, or Traversal.

locally l f ≡ ilocally l f . const
ilocally l f ≡ locally l f . Indexed

ilocally :: MonadReader s m => IndexedLens s s a b      -> (i -> a -> b) -> m r -> m r
ilocally :: MonadReader s m => IndexedTraversal s s a b -> (i -> a -> b) -> m r -> m r
ilocally :: MonadReader s m => IndexedSetter s s a b    -> (i -> a -> b) -> m r -> m r

iover :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t Source #

Map with index. This is an alias for imapOf.

When you do not need access to the index, then over is more liberal in what it can accept.

over l ≡ iover l . const
iover l ≡ over l . Indexed

iover :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
iover :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
iover :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t Source #

Set with index. Equivalent to iover with the current value ignored.

When you do not need access to the index, then set is more liberal in what it can accept.

set l ≡ iset l . const

iset :: IndexedSetter i s t a b    -> (i -> b) -> s -> t
iset :: IndexedLens i s t a b      -> (i -> b) -> s -> t
iset :: IndexedTraversal i s t a b -> (i -> b) -> s -> t

isets :: ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b Source #

Build an IndexedSetter from an imap-like function.

Your supplied function f is required to satisfy:

f id ≡ id
f g . f h ≡ f (g . h)

Equational reasoning:

isets . iover ≡ id
iover . isets ≡ id

Another way to view isets is that it takes a "semantic editor combinator" which has been modified to carry an index and transforms it into a IndexedSetter.

imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m () Source #

This is an alias for (%@=).

assignA :: Arrow p => ASetter s t a b -> p s b -> p s t Source #

Run an arrow command and use the output to set all the targets of a Lens, Setter or Traversal to the result.

assignA can be used very similarly to (<~), except that the type of the object being modified can change; for example:

runKleisli action ((), (), ()) where
  action =      assignA _1 (Kleisli (const getVal1))
           >>> assignA _2 (Kleisli (const getVal2))
           >>> assignA _3 (Kleisli (const getVal3))
  getVal1 :: Either String Int
  getVal1 = ...
  getVal2 :: Either String Bool
  getVal2 = ...
  getVal3 :: Either String Char
  getVal3 = ...

has the type Either String (Int, Bool, Char)

assignA :: Arrow p => Iso s t a b       -> p s b -> p s t
assignA :: Arrow p => Lens s t a b      -> p s b -> p s t
assignA :: Arrow p => Traversal s t a b -> p s b -> p s t
assignA :: Arrow p => Setter s t a b    -> p s b -> p s t

mapOf :: ASetter s t a b -> (a -> b) -> s -> t Source #

Deprecated: Use over

mapOf is a deprecated alias for over.

imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t Source #

Deprecated: Use iover

Map with index. (Deprecated alias for iover).

When you do not need access to the index, then mapOf is more liberal in what it can accept.

mapOf l ≡ imapOf l . const

imapOf :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
imapOf :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
imapOf :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

type AnIndexedLens' i s a = AnIndexedLens i s s a a Source #

type AnIndexedLens' = Simple (AnIndexedLens i)

type AnIndexedLens i s t a b = Optical (Indexed i) (->) (Pretext (Indexed i) a b) s t a b Source #

When you see this as an argument to a function, it expects an IndexedLens

type ALens' s a = ALens s s a a Source #

type ALens' = Simple ALens

type ALens s t a b = LensLike (Pretext (->) a b) s t a b Source #

When you see this as an argument to a function, it expects a Lens.

This type can also be used when you need to store a Lens in a container, since it is rank-1. You can turn them back into a Lens with cloneLens, or use it directly with combinators like storing and (^#).

lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b Source #

Build a Lens from a getter and a setter.

lens :: Functor f => (s -> a) -> (s -> b -> t) -> (a -> f b) -> s -> f t

>>> s ^. lens getter setter
getter s

>>> s & lens getter setter .~ b
setter s b

>>> s & lens getter setter %~ f
setter s (f (getter s))

lens :: (s -> a) -> (s -> a -> s) -> Lens' s a

withLens :: forall s t a b rep (r :: TYPE rep). ALens s t a b -> ((s -> a) -> (s -> b -> t) -> r) -> r Source #

Obtain a getter and a setter from a lens, reversing lens.

iplens :: (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b Source #

Build an index-preserving Lens from a Getter and a Setter.

ilens :: (s -> (i, a)) -> (s -> b -> t) -> IndexedLens i s t a b Source #

Build an IndexedLens from a Getter and a Setter.

inside :: Corepresentable p => ALens s t a b -> Lens (p e s) (p e t) (p e a) (p e b) Source #

Lift a Lens so it can run under a function (or other corepresentable profunctor).

inside :: Lens s t a b -> Lens (e -> s) (e -> t) (e -> a) (e -> b)

>>> (\x -> (x-1,x+1)) ^. inside _1 $ 5
4

>>> runState (modify (1:) >> modify (2:)) ^. (inside _2) $ []
[2,1]

choosing :: Functor f => LensLike f s t a b -> LensLike f s' t' a b -> LensLike f (Either s s') (Either t t') a b Source #

Merge two lenses, getters, setters, folds or traversals.

chosen ≡ choosing id id

choosing :: Getter s a     -> Getter s' a     -> Getter (Either s s') a
choosing :: Fold s a       -> Fold s' a       -> Fold (Either s s') a
choosing :: Lens' s a      -> Lens' s' a      -> Lens' (Either s s') a
choosing :: Traversal' s a -> Traversal' s' a -> Traversal' (Either s s') a
choosing :: Setter' s a    -> Setter' s' a    -> Setter' (Either s s') a

chosen :: IndexPreservingLens (Either a a) (Either b b) a b Source #

This is a Lens that updates either side of an Either, where both sides have the same type.

chosen ≡ choosing id id

>>> Left a^.chosen
a

>>> Right a^.chosen
a

>>> Right "hello"^.chosen
"hello"

>>> Right a & chosen *~ b
Right (a * b)

chosen :: Lens (Either a a) (Either b b) a b
chosen f (Left a)  = Left <$> f a
chosen f (Right a) = Right <$> f a

alongside :: LensLike (AlongsideLeft f b') s t a b -> LensLike (AlongsideRight f t) s' t' a' b' -> LensLike f (s, s') (t, t') (a, a') (b, b') Source #

alongside makes a Lens from two other lenses or a Getter from two other getters by executing them on their respective halves of a product.

>>> (Left a, Right b)^.alongside chosen chosen
(a,b)

>>> (Left a, Right b) & alongside chosen chosen .~ (c,d)
(Left c,Right d)

alongside :: Lens   s t a b -> Lens   s' t' a' b' -> Lens   (s,s') (t,t') (a,a') (b,b')
alongside :: Getter s   a   -> Getter s'    a'    -> Getter (s,s')        (a,a')

locus :: IndexedComonadStore p => Lens (p a c s) (p b c s) a b Source #

This Lens lets you view the current pos of any indexed store comonad and seek to a new position. This reduces the API for working these instances to a single Lens.

ipos w ≡ w ^. locus
iseek s w ≡ w & locus .~ s
iseeks f w ≡ w & locus %~ f

locus :: Lens' (Context' a s) a
locus :: Conjoined p => Lens' (Pretext' p a s) a
locus :: Conjoined p => Lens' (PretextT' p g a s) a

cloneLens :: ALens s t a b -> Lens s t a b Source #

Cloning a Lens is one way to make sure you aren't given something weaker, such as a Traversal and can be used as a way to pass around lenses that have to be monomorphic in f.

Note: This only accepts a proper Lens.

>>> let example l x = set (cloneLens l) (x^.cloneLens l + 1) x in example _2 ("hello",1,"you")
("hello",2,"you")

cloneIndexPreservingLens :: ALens s t a b -> IndexPreservingLens s t a b Source #

Clone a Lens as an IndexedPreservingLens that just passes through whatever index is on any IndexedLens, IndexedFold, IndexedGetter or IndexedTraversal it is composed with.

cloneIndexedLens :: AnIndexedLens i s t a b -> IndexedLens i s t a b Source #

Clone an IndexedLens as an IndexedLens with the same index.

overA :: Arrow ar => LensLike (Context a b) s t a b -> ar a b -> ar s t Source #

over for Arrows.

Unlike over, overA can't accept a simple Setter, but requires a full lens, or close enough.

>>> overA _1 ((+1) *** (+2)) ((1,2),6)
((2,4),6)

overA :: Arrow ar => Lens s t a b -> ar a b -> ar s t

storing :: ALens s t a b -> b -> s -> t Source #

A version of set that works on ALens.

>>> storing _2 "world" ("hello","there")
("hello","world")

devoid :: Over p f Void Void a b Source #

There is a field for every type in the Void. Very zen.

>>> [] & mapped.devoid +~ 1
[]

>>> Nothing & mapped.devoid %~ abs
Nothing

devoid :: Lens' Void a

united :: Lens' a () Source #

We can always retrieve a () from any type.

>>> "hello"^.united
()

>>> "hello" & united .~ ()
"hello"

head1 :: Traversable1 t => Lens' (t a) a Source #

A Lens focusing on the first element of a Traversable1 container.

>>> 2 :| [3, 4] & head1 +~ 10
12 :| [3,4]

>>> Identity True ^. head1
True

last1 :: Traversable1 t => Lens' (t a) a Source #

A Lens focusing on the last element of a Traversable1 container.

>>> 2 :| [3, 4] & last1 +~ 10
2 :| [3,14]

>>> Node 'a' [Node 'b' [], Node 'c' []] ^. last1
'c'

fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b Source #

Fuse a composition of lenses using Yoneda to provide fmap fusion.

In general, given a pair of lenses foo and bar

fusing (foo.bar) = foo.bar

however, foo and bar are either going to fmap internally or they are trivial.

fusing exploits the Yoneda lemma to merge these separate uses into a single fmap.

This is particularly effective when the choice of functor f is unknown at compile time or when the Lens foo.bar in the above description is recursive or complex enough to prevent inlining.

fusing :: Lens s t a b -> Lens s t a b

class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 19th field of a tuple.

Minimal complete definition

Nothing

Methods

_19 :: Lens s t a b Source #

Access the 19th field of a tuple.

default _19 :: (Generic s, Generic t, GIxed N18 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field19 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s') s s' Source #
Instance details Defined in Control.Lens.Tuple Methods _19 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s') s s' Source #

class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 18th field of a tuple.

Minimal complete definition

Nothing

Methods

_18 :: Lens s t a b Source #

Access the 18th field of a tuple.

default _18 :: (Generic s, Generic t, GIxed N17 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field18 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r') r r' Source #
Instance details Defined in Control.Lens.Tuple Methods _18 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r') r r' Source #
Field18 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s) r r' Source #
Instance details Defined in Control.Lens.Tuple Methods _18 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s) r r' Source #

class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 17th field of a tuple.

Minimal complete definition

Nothing

Methods

_17 :: Lens s t a b Source #

Access the 17th field of a tuple.

default _17 :: (Generic s, Generic t, GIxed N16 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field17 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q') q q' Source #
Instance details Defined in Control.Lens.Tuple Methods _17 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q') q q' Source #
Field17 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r) q q' Source #
Instance details Defined in Control.Lens.Tuple Methods _17 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r) q q' Source #
Field17 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s) q q' Source #
Instance details Defined in Control.Lens.Tuple Methods _17 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s) q q' Source #

class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 16th field of a tuple.

Minimal complete definition

Nothing

Methods

_16 :: Lens s t a b Source #

Access the 16th field of a tuple.

default _16 :: (Generic s, Generic t, GIxed N15 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p') p p' Source #
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p') p p' Source #
Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q) p p' Source #
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q) p p' Source #
Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r) p p' Source #
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r) p p' Source #
Field16 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s) p p' Source #
Instance details Defined in Control.Lens.Tuple Methods _16 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s) p p' Source #

class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 15th field of a tuple.

Minimal complete definition

Nothing

Methods

_15 :: Lens s t a b Source #

Access the 15th field of a tuple.

default _15 :: (Generic s, Generic t, GIxed N14 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o') o o' Source #
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o') o o' Source #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p) o o' Source #
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p) o o' Source #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q) o o' Source #
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q) o o' Source #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r) o o' Source #
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r) o o' Source #
Field15 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s) o o' Source #
Instance details Defined in Control.Lens.Tuple Methods _15 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s) o o' Source #

class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 14th field of a tuple.

Minimal complete definition

Nothing

Methods

_14 :: Lens s t a b Source #

Access the 14th field of a tuple.

default _14 :: (Generic s, Generic t, GIxed N13 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n') n n' Source #
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n') n n' Source #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o) n n' Source #
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o) n n' Source #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p) n n' Source #
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p) n n' Source #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q) n n' Source #
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q) n n' Source #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r) n n' Source #
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r) n n' Source #
Field14 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s) n n' Source #
Instance details Defined in Control.Lens.Tuple Methods _14 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s) n n' Source #

class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 13th field of a tuple.

Minimal complete definition

Nothing

Methods

_13 :: Lens s t a b Source #

Access the 13th field of a tuple.

default _13 :: (Generic s, Generic t, GIxed N12 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l, m') m m' Source #
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l, m') m m' Source #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n) m m' Source #
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n) m m' Source #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o) m m' Source #
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o) m m' Source #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p) m m' Source #
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p) m m' Source #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q) m m' Source #
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q) m m' Source #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r) m m' Source #
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r) m m' Source #
Field13 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s) m m' Source #
Instance details Defined in Control.Lens.Tuple Methods _13 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s) m m' Source #

class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 12th field of a tuple.

Minimal complete definition

Nothing

Methods

_12 :: Lens s t a b Source #

Access the 12th field of a tuple.

default _12 :: (Generic s, Generic t, GIxed N11 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field12 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk, l') l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk, l') l l' Source #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l', m) l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk, l', m) l l' Source #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n) l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n) l l' Source #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o) l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o) l l' Source #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p) l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p) l l' Source #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q) l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q) l l' Source #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r) l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r) l l' Source #
Field12 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s) l l' Source #
Instance details Defined in Control.Lens.Tuple Methods _12 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s) l l' Source #

class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 11th field of a tuple.

Minimal complete definition

Nothing

Methods

_11 :: Lens s t a b Source #

Access the 11th field of a tuple.

default _11 :: (Generic s, Generic t, GIxed N10 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field11 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j, kk') kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j, kk') kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk', l) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j, kk', l) kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk', l, m) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j, kk', l, m) kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n) kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o) kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p) kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q) kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r) kk kk' Source #
Field11 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s) kk kk' Source #
Instance details Defined in Control.Lens.Tuple Methods _11 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s) kk kk' Source #

class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 10th field of a tuple.

Minimal complete definition

Nothing

Methods

_10 :: Lens s t a b Source #

Access the 10th field of a tuple.

default _10 :: (Generic s, Generic t, GIxed N9 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field10 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i, j') j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i, j') j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j', kk) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i, j', kk) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j', kk, l) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i, j', kk, l) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j', kk, l, m) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i, j', kk, l, m) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r) j j' Source #
Field10 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s) j j' Source #
Instance details Defined in Control.Lens.Tuple Methods _10 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s) j j' Source #

class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 9th field of a tuple.

Minimal complete definition

Nothing

Methods

_9 :: Lens s t a b Source #

Access the 9th field of a tuple.

default _9 :: (Generic s, Generic t, GIxed N8 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field9 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i', j) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i', j) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i', j, kk) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h, i', j, kk) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i', j, kk, l) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h, i', j, kk, l) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i', j, kk, l, m) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h, i', j, kk, l, m) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r) i i' Source #
Field9 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s) i i' Source #
Instance details Defined in Control.Lens.Tuple Methods _9 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s) i i' Source #

class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provide access to the 8th field of a tuple.

Minimal complete definition

Nothing

Methods

_8 :: Lens s t a b Source #

Access the 8th field of a tuple.

default _8 :: (Generic s, Generic t, GIxed N7 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field8 (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h' Source #
Field8 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h', i, j) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h', i, j) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h', i, j, kk) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g, h', i, j, kk) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h', i, j, kk, l) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g, h', i, j, kk, l) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h', i, j, kk, l, m) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g, h', i, j, kk, l, m) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r) h h' Source #
Field8 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s) h h' Source #
Instance details Defined in Control.Lens.Tuple Methods _8 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s) h h' Source #

class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provide access to the 7th field of a tuple.

Minimal complete definition

Nothing

Methods

_7 :: Lens s t a b Source #

Access the 7th field of a tuple.

default _7 :: (Generic s, Generic t, GIxed N6 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field7 (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g' Source #
Field7 (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g', h, i, j) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g', h, i, j) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g', h, i, j, kk) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f, g', h, i, j, kk) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g', h, i, j, kk, l) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f, g', h, i, j, kk, l) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g', h, i, j, kk, l, m) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f, g', h, i, j, kk, l, m) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r) g g' Source #
Field7 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s) g g' Source #
Instance details Defined in Control.Lens.Tuple Methods _7 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s) g g' Source #

class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 6th element of a tuple.

Minimal complete definition

Nothing

Methods

_6 :: Lens s t a b Source #

Access the 6th field of a tuple.

default _6 :: (Generic s, Generic t, GIxed N5 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field6 (a, b, c, d, e, f) (a, b, c, d, e, f') f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f' Source #
Field6 (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f' Source #
Field6 (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f', g, h, i, j) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f', g, h, i, j) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f', g, h, i, j, kk) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e, f', g, h, i, j, kk) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f', g, h, i, j, kk, l) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e, f', g, h, i, j, kk, l) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f', g, h, i, j, kk, l, m) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e, f', g, h, i, j, kk, l, m) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r) f f' Source #
Field6 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s) f f' Source #
Instance details Defined in Control.Lens.Tuple Methods _6 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s) f f' Source #

class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 5th field of a tuple.

Minimal complete definition

Nothing

Methods

_5 :: Lens s t a b Source #

Access the 5th field of a tuple.

default _5 :: (Generic s, Generic t, GIxed N4 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field5 (a, b, c, d, e) (a, b, c, d, e') e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e) (a, b, c, d, e') e e' Source #
Field5 (a, b, c, d, e, f) (a, b, c, d, e', f) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e' Source #
Field5 (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e' Source #
Field5 (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e', f, g, h, i, j) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e', f, g, h, i, j) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e', f, g, h, i, j, kk) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d, e', f, g, h, i, j, kk) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e', f, g, h, i, j, kk, l) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d, e', f, g, h, i, j, kk, l) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e', f, g, h, i, j, kk, l, m) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d, e', f, g, h, i, j, kk, l, m) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r) e e' Source #
Field5 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s) e e' Source #
Instance details Defined in Control.Lens.Tuple Methods _5 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s) e e' Source #

class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provide access to the 4th field of a tuple.

Minimal complete definition

Nothing

Methods

_4 :: Lens s t a b Source #

Access the 4th field of a tuple.

default _4 :: (Generic s, Generic t, GIxed N3 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field4 (a, b, c, d) (a, b, c, d') d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d) (a, b, c, d') d d' Source #
Field4 (a, b, c, d, e) (a, b, c, d', e) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e) (a, b, c, d', e) d d' Source #
Field4 (a, b, c, d, e, f) (a, b, c, d', e, f) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d' Source #
Field4 (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d' Source #
Field4 (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j) (a, b, c, d', e, f, g, h, i, j) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c, d', e, f, g, h, i, j) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d', e, f, g, h, i, j, kk) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c, d', e, f, g, h, i, j, kk) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d', e, f, g, h, i, j, kk, l) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c, d', e, f, g, h, i, j, kk, l) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d', e, f, g, h, i, j, kk, l, m) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c, d', e, f, g, h, i, j, kk, l, m) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r) d d' Source #
Field4 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) d d' Source #
Instance details Defined in Control.Lens.Tuple Methods _4 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) d d' Source #

class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 3rd field of a tuple.

Minimal complete definition

Nothing

Methods

_3 :: Lens s t a b Source #

Access the 3rd field of a tuple.

default _3 :: (Generic s, Generic t, GIxed N2 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field3 (a, b, c) (a, b, c') c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c) (a, b, c') c c' Source #
Field3 (a, b, c, d) (a, b, c', d) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d) (a, b, c', d) c c' Source #
Field3 (a, b, c, d, e) (a, b, c', d, e) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e) (a, b, c', d, e) c c' Source #
Field3 (a, b, c, d, e, f) (a, b, c', d, e, f) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c' Source #
Field3 (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c' Source #
Field3 (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j) (a, b, c', d, e, f, g, h, i, j) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b, c', d, e, f, g, h, i, j) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c', d, e, f, g, h, i, j, kk) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b, c', d, e, f, g, h, i, j, kk) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c', d, e, f, g, h, i, j, kk, l) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b, c', d, e, f, g, h, i, j, kk, l) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c', d, e, f, g, h, i, j, kk, l, m) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b, c', d, e, f, g, h, i, j, kk, l, m) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r) c c' Source #
Field3 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) c c' Source #
Instance details Defined in Control.Lens.Tuple Methods _3 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s) c c' Source #

class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where Source #

Provides access to the 2nd field of a tuple.

Minimal complete definition

Nothing

Methods

_2 :: Lens s t a b Source #

Access the 2nd field of a tuple.

>>> _2 .~ "hello" $ (1,(),3,4)
(1,"hello",3,4)

>>> (1,2,3,4) & _2 *~ 3
(1,6,3,4)

>>> _2 print (1,2)
2
(1,())

anyOf _2 :: (s -> Bool) -> (a, s) -> Bool
traverse . _2 :: (Applicative f, Traversable t) => (a -> f b) -> t (s, a) -> f (t (s, b))
foldMapOf (traverse . _2) :: (Traversable t, Monoid m) => (s -> m) -> t (b, s) -> m

default _2 :: (Generic s, Generic t, GIxed N1 (Rep s) (Rep t) a b) => Lens s t a b Source #

Instances

Instances details

Field2 (Pair a b) (Pair a b') b b' Source #	Since: 4.20
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (Pair a b) (Pair a b') b b' Source #
Field2 (a, b) (a, b') b b' Source #	`_2` k ~(a,b) = (\b' -> (a,b')) `<$>` k b
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b) (a, b') b b' Source #
Field2 (a, b, c) (a, b', c) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c) (a, b', c) b b' Source #
Field2 (a, b, c, d) (a, b', c, d) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d) (a, b', c, d) b b' Source #
Field2 (Product f g a) (Product f g' a) (g a) (g' a) Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (Product f g a) (Product f g' a) (g a) (g' a) Source #
Field2 ((f :: g) p) ((f :: g') p) (g p) (g' p) Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens ((f :: g) p) ((f :: g') p) (g p) (g' p) Source #
Field2 (a, b, c, d, e) (a, b', c, d, e) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e) (a, b', c, d, e) b b' Source #
Field2 (a, b, c, d, e, f) (a, b', c, d, e, f) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b' Source #
Field2 (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b' Source #
Field2 (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b' Source #
Field2 (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b' Source #
Field2 (a, b, c, d, e, f, g, h, i, j) (a, b', c, d, e, f, g, h, i, j) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j) (a, b', c, d, e, f, g, h, i, j) b b' Source #
Field2 (a, b, c, d, e, f, g, h, i, j, kk) (a, b', c, d, e, f, g, h, i, j, kk) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk) (a, b', c, d, e, f, g, h, i, j, kk) b b' Source #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b', c, d, e, f, g, h, i, j, kk, l) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l) (a, b', c, d, e, f, g, h, i, j, kk, l) b b' Source #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b', c, d, e, f, g, h, i, j, kk, l, m) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m) (a, b', c, d, e, f, g, h, i, j, kk, l, m) b b' Source #
Field2 (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n) b b' Source #
Instance details Defined in Control.Lens.Tuple Methods _2 :: Lens (a, b, c, d, e, f, g, h, i, j, kk, l, m, n) (a, b', c, d, e, f, g, h, i, j, kk, l, m, n) b b' Source #