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

Control.Lens.Internal.Indexed

Contents

An Indexed Profunctor
Classes
Indexing
64-bit Indexing
Converting to Folds

Description

Internal implementation details for Indexed lens-likes

Synopsis

newtype Indexed i a b = Indexed {
- runIndexed :: 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 :: Type -> Type -> Type) 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
class Conjoined p => Indexable i (p :: Type -> Type -> Type) where
- indexed :: p a b -> i -> a -> b
newtype Indexing (f :: Type -> Type) a = Indexing {
- runIndexing :: Int -> (Int, f a)
}
indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
newtype Indexing64 (f :: Type -> Type) a = Indexing64 {
- runIndexing64 :: Int64 -> (Int64, f a)
}
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)

An Indexed Profunctor

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

Category (Indexed i :: Type -> Type -> Type) Source #

Instance details

Defined in Control.Lens.Internal.Indexed

Methods

id :: Indexed i a a #

(.) :: Indexed i b c -> Indexed i a b -> Indexed i a c #

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 #

first :: Indexed i b c -> Indexed i (b, d) (c, d) #

second :: Indexed i b c -> Indexed i (d, b) (d, c) #

(***) :: Indexed i b c -> Indexed i b' c' -> Indexed i (b, b') (c, c') #

(&&&) :: Indexed i b c -> Indexed i b c' -> Indexed i b (c, c') #

ArrowApply (Indexed i) Source #

Instance details

Defined in Control.Lens.Internal.Indexed

Methods

app :: Indexed i (Indexed i b c, b) c #

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

right :: Indexed i b c -> Indexed i (Either d b) (Either d c) #

(+++) :: Indexed i b c -> Indexed i b' c' -> Indexed i (Either b b') (Either c c') #

(|||) :: Indexed i b d -> Indexed i c d -> Indexed i (Either b c) d #

ArrowLoop (Indexed i) Source #

Instance details

Defined in Control.Lens.Internal.Indexed

Methods

loop :: Indexed i (b, d) (c, d) -> Indexed i b c #

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)
Instance details Defined in Control.Lens.Internal.Indexed type Corep (Indexed i) = (,) i

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)
Instance details Defined in Control.Lens.Internal.Indexed type Rep (Indexed i) = (->) i

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 #

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 #

Applicative (Indexed i a) Source #

Instance details

Defined in Control.Lens.Internal.Indexed

Methods

pure :: a0 -> Indexed i a a0 #

(<*>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b #

liftA2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c #

(*>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b #

(<*) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0 #

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 #

(<$) :: a0 -> Indexed i a b -> Indexed i a a0 #

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 #

(>>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b #

return :: a0 -> Indexed i a a0 #

MonadFix (Indexed i a) Source #

Instance details

Defined in Control.Lens.Internal.Indexed

Methods

mfix :: (a0 -> Indexed i a a0) -> Indexed i a a0 #

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

Classes

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 :: Type -> Type -> Type) 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 #

class Conjoined p => Indexable i (p :: Type -> Type -> Type) 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 #

Indexing

newtype Indexing (f :: Type -> Type) a Source #

Applicative composition of State Int with a Functor, used by indexed.

Constructors

Indexing
Fields runIndexing :: Int -> (Int, f a)

Instances

Instances details

Contravariant f => Contravariant (Indexing f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods contramap :: (a' -> a) -> Indexing f a -> Indexing f a' # (>$) :: b -> Indexing f b -> Indexing f a #
Applicative f => Applicative (Indexing f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods pure :: a -> Indexing f a # (<>) :: Indexing f (a -> b) -> Indexing f a -> Indexing f b # liftA2 :: (a -> b -> c) -> Indexing f a -> Indexing f b -> Indexing f c # (>) :: Indexing f a -> Indexing f b -> Indexing f b # (<*) :: Indexing f a -> Indexing f b -> Indexing f a #
Functor f => Functor (Indexing f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods fmap :: (a -> b) -> Indexing f a -> Indexing f b # (<$) :: a -> Indexing f b -> Indexing f a #
Apply f => Apply (Indexing f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods (<.>) :: Indexing f (a -> b) -> Indexing f a -> Indexing f b Source # (.>) :: Indexing f a -> Indexing f b -> Indexing f b Source # (<.) :: Indexing f a -> Indexing f b -> Indexing f a Source # liftF2 :: (a -> b -> c) -> Indexing f a -> Indexing f b -> Indexing f c Source #
Monoid (f a) => Monoid (Indexing f a) Source #	`>>>` `"cat" ^@.. (folded <> folded)`[(0,'c'),(1,'a'),(2,'t'),(0,'c'),(1,'a'),(2,'t')] `>>>` `"cat" ^@.. indexing (folded <> folded)`[(0,'c'),(1,'a'),(2,'t'),(3,'c'),(4,'a'),(5,'t')]
Instance details Defined in Control.Lens.Internal.Indexed Methods mempty :: Indexing f a # mappend :: Indexing f a -> Indexing f a -> Indexing f a # mconcat :: [Indexing f a] -> Indexing f a #
Semigroup (f a) => Semigroup (Indexing f a) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods (<>) :: Indexing f a -> Indexing f a -> Indexing f a # sconcat :: NonEmpty (Indexing f a) -> Indexing f a # stimes :: Integral b => b -> Indexing f a -> Indexing f a #

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

64-bit Indexing

newtype Indexing64 (f :: Type -> Type) a Source #

Applicative composition of State Int64 with a Functor, used by indexed64.

Constructors

Indexing64
Fields runIndexing64 :: Int64 -> (Int64, f a)

Instances

Instances details

Contravariant f => Contravariant (Indexing64 f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods contramap :: (a' -> a) -> Indexing64 f a -> Indexing64 f a' # (>$) :: b -> Indexing64 f b -> Indexing64 f a #
Applicative f => Applicative (Indexing64 f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods pure :: a -> Indexing64 f a # (<>) :: Indexing64 f (a -> b) -> Indexing64 f a -> Indexing64 f b # liftA2 :: (a -> b -> c) -> Indexing64 f a -> Indexing64 f b -> Indexing64 f c # (>) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f b # (<*) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f a #
Functor f => Functor (Indexing64 f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods fmap :: (a -> b) -> Indexing64 f a -> Indexing64 f b # (<$) :: a -> Indexing64 f b -> Indexing64 f a #
Apply f => Apply (Indexing64 f) Source #
Instance details Defined in Control.Lens.Internal.Indexed Methods (<.>) :: Indexing64 f (a -> b) -> Indexing64 f a -> Indexing64 f b Source # (.>) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f b Source # (<.) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f a Source # liftF2 :: (a -> b -> c) -> Indexing64 f a -> Indexing64 f b -> Indexing64 f c Source #

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

Converting to Folds

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.