Data.Profunctor.Optic.Traversal

Traversal & Ixtraversal

type Traversal s t a b = forall p. (Choice p, Representable p, Applicative (Rep p)) => Optic p s t a b

A Traversal processes 0 or more parts of the whole, with Applicative interactions.

\( \mathsf{Traversal}\;S\;A = \exists F : \mathsf{Traversable}, S \equiv F\,A \)

type Traversal' s a = Traversal s s a a

type Ixtraversal i s t a b = forall p. (Choice p, Representable p, Applicative (Rep p)) => IndexedOptic p i s t a b

type Ixtraversal' i s a = Ixtraversal i s s a a

type ATraversal f s t a b = Applicative f => ARepn f s t a b

type ATraversal' f s a = ATraversal f s s a a

traversing :: Traversable f => (s -> a) -> (s -> b -> t) -> Traversal (f s) (f t) a b

Obtain a Traversal by lifting a lens getter and setter into a Traversable functor.

 withLens o traversing ≡ traversed . o

Compare folding.

Caution: In order for the generated optic to be well-defined, you must ensure that the input functions constitute a legal lens:

• sa (sbt s a) ≡ a

• sbt s (sa s) ≡ s

• sbt (sbt s a1) a2 ≡ sbt s a2

See Property.

The resulting optic can detect copies of the lens stucture inside any Traversable container. For example:

>>> lists (traversing snd $ \(s,_) b -> (s,b)) [(0,'f'),(1,'o'),(2,'o'),(3,'b'),(4,'a'),(5,'r')]
"foobar"

ixtraversing :: Monoid i => Traversable f => (s -> (i, a)) -> (s -> b -> t) -> Ixtraversal i (f s) (f t) a b

Obtain a Ixtraversal by lifting an indexed lens getter and setter into a Traversable functor.

 withIxlens o ixtraversing ≡ ixtraversed . o

Caution: In order for the generated optic to be well-defined, you must ensure that the input functions constitute a legal indexed lens:

• snd . sia (sbt s a) ≡ a

• sbt s (snd $ sia s) ≡ s

• sbt (sbt s a1) a2 ≡ sbt s a2

See Property.

traversalVl :: (forall f. Applicative f => (a -> f b) -> s -> f t) -> Traversal s t a b

Obtain a profunctor Traversal from a Van Laarhoven Traversal.

Caution: In order for the generated optic to be well-defined, you must ensure that the input satisfies the following properties:

• abst pure ≡ pure

• fmap (abst f) . abst g ≡ getCompose . abst (Compose . fmap f . g)

See Property.

ixtraversalVl :: (forall f. Applicative f => (i -> a -> f b) -> s -> f t) -> Ixtraversal i s t a b

Lift an indexed VL traversal into an indexed profunctor traversal.

Caution: In order for the generated optic to be well-defined, you must ensure that the input satisfies the following properties:

• iabst (const pure) ≡ pure

• fmap (iabst $ const f) . (iabst $ const g) ≡ getCompose . iabst (const $ Compose . fmap f . g)

See Property.

noix :: Monoid i => Traversal s t a b -> Ixtraversal i s t a b

Lift a VL traversal into an indexed profunctor traversal that ignores its input.

Useful as the first optic in a chain when no indexed equivalent is at hand.

>>> ixlists (noix traversed . ixtraversed) ["foo", "bar"]
[(0,'f'),(1,'o'),(2,'o'),(0,'b'),(1,'a'),(2,'r')]

>>> ixlists (ixtraversed . noix traversed) ["foo", "bar"]
[(0,'f'),(0,'o'),(0,'o'),(0,'b'),(0,'a'),(0,'r')]

ix :: Monoid i => Semiring i => Traversal s t a b -> Ixtraversal i s t a b

Index a traversal with a Semiring.

>>> ixlists (ix traversed . ix traversed) ["foo", "bar"]
[((),'f'),((),'o'),((),'o'),((),'b'),((),'a'),((),'r')]

>>> ixlists (ix @Int traversed . ix traversed) ["foo", "bar"]
[(0,'f'),(1,'o'),(2,'o'),(0,'b'),(1,'a'),(2,'r')]

>>> ixlists (ix @[()] traversed . ix traversed) ["foo", "bar"]
[([],'f'),([()],'o'),([(),()],'o'),([],'b'),([()],'a'),([(),()],'r')]

>>> ixlists (ix @[()] traversed % ix traversed) ["foo", "bar"]
[([],'f'),([()],'o'),([(),()],'o'),([()],'b'),([(),()],'a'),([(),(),()],'r')]

Primitive operators

withTraversal :: Applicative f => ATraversal f s t a b -> (a -> f b) -> s -> f t

The traversal laws can be stated in terms of withTraversal:

Identity:

withTraversal t (Identity . f) ≡  Identity (fmap f)

Composition:

Compose . fmap (withTraversal t f) . withTraversal t g ≡ withTraversal t (Compose . fmap f . g)

withTraversal :: Functor f => Lens s t a b -> (a -> f b) -> s -> f t
withTraversal :: Applicative f => Traversal s t a b -> (a -> f b) -> s -> f t

Optics

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

TODO: Document

both :: Traversal (a, a) (b, b) a b

TODO: Document

>>> withTraversal both (pure . length) ("hello","world")
(5,5)

duplicated :: Traversal a b a b

Duplicate the results of any Fold.

>>> lists (both . duplicated) ("hello","world")
["hello","hello","world","world"]

bitraversed :: Bitraversable f => Traversal (f a a) (f b b) a b

Traverse both parts of a Bitraversable container with matching types.

>>> withTraversal bitraversed (pure . length) (Right "hello")
Right 5

>>> withTraversal bitraversed (pure . length) ("hello","world")
(5,5)

>>> ("hello","world") ^. bitraversed
"helloworld"

bitraversed :: Traversal (a , a) (b , b) a b
bitraversed :: Traversal (a + a) (b + b) a b

Operators

sequences :: Applicative f => ATraversal f s t (f a) a -> s -> f t

TODO: Document

Carriers

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

Lift a Functor into a Profunctor (forwards).

Constructors

Star

Fields

• runStar :: d -> f c

Instances

Functor f => Representable (Star f)

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Applicative f => Choice (Star f)

Defined in Data.Profunctor.Choice

Methods

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

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

Traversable f => Cochoice (Star f)

Defined in Data.Profunctor.Choice

Methods

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

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

Distributive f => Closed (Star f)

Defined in Data.Profunctor.Closed

Methods

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

Functor m => Strong (Star m)

Defined in Data.Profunctor.Strong

Methods

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

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

Functor f => Profunctor (Star f)

Defined in Data.Profunctor.Types

Methods

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

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

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

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

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

Functor f => Sieve (Star f) f

Defined in Data.Profunctor.Sieve

Methods

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

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

Defined in Data.Profunctor.Types

Methods

id :: Star f a a

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

Monad f => Monad (Star f a)

Defined in Data.Profunctor.Types

Methods

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

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

return :: a0 -> Star f a a0

fail :: String -> Star f a a0

Functor f => Functor (Star f a)

Defined in Data.Profunctor.Types

Methods

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

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

Applicative f => Applicative (Star f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Star f a a0

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

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

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

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

Contravariant f => Contravariant (Star f a)

Defined in Data.Profunctor.Optic.Type

Methods

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

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

Alternative f => Alternative (Star f a)

Defined in Data.Profunctor.Types

Methods

empty :: Star f a a0

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

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

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

MonadPlus f => MonadPlus (Star f a)

Defined in Data.Profunctor.Types

Methods

mzero :: Star f a a0

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

Distributive f => Distributive (Star f a)

Defined in Data.Profunctor.Types

Methods

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

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

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

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

Apply f => Apply (Star f a)

Defined in Data.Profunctor.Optic.Type

Methods

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

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

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

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

type Rep (Star f)

Defined in Data.Profunctor.Rep

type Rep (Star f) = f

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

Lift a Functor into a Profunctor (backwards).

Constructors

Costar

Fields

• runCostar :: f d -> c

Instances

Contravariant f => Bifunctor (Costar f)

Defined in Data.Profunctor.Optic.Type

Methods

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

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

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

Functor f => Corepresentable (Costar f)

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Traversable w => Choice (Costar w)

Defined in Data.Profunctor.Choice

Methods

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

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

Applicative f => Cochoice (Costar f)

Defined in Data.Profunctor.Choice

Methods

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

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

Functor f => Closed (Costar f)

Defined in Data.Profunctor.Closed

Methods

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

Comonad f => Strong (Costar f)

Defined in Data.Profunctor.Optic.Type

Methods

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

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

Functor f => Costrong (Costar f)

Defined in Data.Profunctor.Strong

Methods

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

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

Functor f => Profunctor (Costar f)

Defined in Data.Profunctor.Types

Methods

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

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

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

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

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

Functor f => Cosieve (Costar f) f

Defined in Data.Profunctor.Sieve

Methods

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

Monad (Costar f a)

Defined in Data.Profunctor.Types

Methods

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

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

return :: a0 -> Costar f a a0

fail :: String -> Costar f a a0

Functor (Costar f a)

Defined in Data.Profunctor.Types

Methods

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

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

Applicative (Costar f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Costar f a a0

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

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

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

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

Distributive (Costar f d)

Defined in Data.Profunctor.Types

Methods

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

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

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

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

type Corep (Costar f)

Defined in Data.Profunctor.Rep

type Corep (Costar f) = f

Classes

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

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

Associated Types

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

Methods

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

Laws:

tabulate . sieve ≡ id
sieve . tabulate ≡ id

Instances

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

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Functor f => Representable (Star f)

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Representable (Forget r)

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Representable (Fold0Rep r)

Defined in Data.Profunctor.Optic.Fold0

Associated Types

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

Methods

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

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

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Representable (LensRep a b)

Defined in Data.Profunctor.Optic.Lens

Associated Types

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

Methods

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

Representable (Traversal0Rep a b)

Defined in Data.Profunctor.Optic.Traversal0

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

Laws:

cotabulate . cosieve ≡ id
cosieve . cotabulate ≡ id

Instances

Functor f => Corepresentable (Costar f)

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

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

Defined in Data.Profunctor.Rep

Associated Types

type Corep Tagged :: Type -> Type

Methods

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

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

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Functor w => Corepresentable (Cokleisli w)

Defined in Data.Profunctor.Rep

Associated Types

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

Methods

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

Corepresentable (GrateRep a b)

Defined in Data.Profunctor.Optic.Grate

Associated Types

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

Methods

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