\( \mathsf{Traversal0}\;S\;A = \exists C, D, S \cong D + C \times A \)

Create a Traversal0 from match and constructor functions.

Caution: In order for the Traversal0 to be well-defined, you must ensure that the input functions satisfy the following properties:

• sta (sbt a s) ≡ either (Left . const a) Right (sta s)

• either id (sbt s) (sta s) ≡ s

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

More generally, a profunctor optic must be monoidal as a natural transformation:

• o id ≡ id

• o (Procompose p q) ≡ Procompose (o p) (o q)

See Property.

Obtain a Traversal0' from match and constructor functions.

Transform a Van Laarhoven Traversal0 into a profunctor Traversal0.

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

\( \mathsf{Cotraversal}\;S\;A = \exists F : \mathsf{Distributive}, S \equiv F\,A \)

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"

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)

The traversal laws can be stated in terms of withStar:

• withStar t (pure . f) ≡ pure (fmap f)

• Compose . fmap (withStar t f) . withStar t g ≡ withStar t (Compose . fmap f . g)

See Property.

Obtain a Cotraversal by embedding a continuation into a Distributive functor.

 withGrate o cotraversing ≡ cotraversed . o

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

• sabt ($ s) ≡ s

• sabt (k -> f (k . sabt)) ≡ sabt (k -> f ($ k))

Obtain a Cotraversal by embedding a reversed lens getter and setter into a Distributive functor.

 withLens (re o) cotraversing ≡ cotraversed . o

Obtain a profunctor Cotraversal from a Van Laarhoven Cotraversal.

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

• abst copure ≡ copure

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

The cotraversal laws can be restated in terms of withCostar:

• withCostar o (f . copure) ≡  fmap f . copure

• withCostar o f . fmap (withCostar o g) == withCostar o (f . fmap g . getCompose) . Compose

See Property.

\( \mathsf{Traversal1}\;S\;A = \exists F : \mathsf{Traversable1}, S \equiv F\,A \)

\( \mathsf{Cotraversal1}\;S\;A = \exists F : \mathsf{Distributive1}, S \equiv F\,A \)

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

 withLens o traversing ≡ traversed . o

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"

Compare folding.

Obtain a profunctor Traversal1 from a Van Laarhoven Traversal1.

Caution: In order for the generated family to be well-defined, you must ensure that the traversal1 law holds for the input function:

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

See Property.

Profunctor version of <*>.

Profunctor version of ***.

Profunctor version of &&&.

Profunctor version of divide.

Obtain a Cotraversal1 by embedding a continuation into a Distributive1 functor.

 withGrate o cotraversing1 ≡ cotraversed1 . o

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

• sabt ($ s) ≡ s

• sabt (k -> f (k . sabt)) ≡ sabt (k -> f ($ k))

Obtain a Cotraversal1 by embedding a reversed lens getter and setter into a Distributive1 functor.

 withLens (re o) cotraversing ≡ cotraversed . o

Obtain a profunctor Cotraversal1 from a Van Laarhoven Cotraversal1.

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

• abst runIdentity ≡ runIdentity

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

The cotraversal1 laws can be restated in terms of withCostar:

• withCostar o (f . runIdentity) ≡  fmap f . runIdentity

• withCostar o f . fmap (withCostar o g) == withCostar o (f . fmap g . getCompose) . Compose

See Property.

Profunctor version of +++.

Profunctor version of |||.

Profunctor version of choose.

TODO: Document

TODO: Document

TODO: Document

TODO: Document

Obtain a Traversal1 from a Traversable1 functor.

TODO: Document

TODO: Document

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

TODO: Document

TODO: Document

>>> traverses both1 (pure . NE.length) ('h' :| "ello", 'w' :| "orld")
(5,5)

TODO: Document

>>> cotraverses1 coboth1 (foldMap id) $ Left "foo" :| [Right "bar"]
Left "foo"
>>> cotraverses1 coboth1 (foldMap id) $ Right "foo" :| [Right "bar"]
Right "foobar"

Duplicate the results of a Traversal.

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

TODO: Document

Traverse both parts of a Bitraversable container with matching types.

>>> traverses bitraversed (pure . length) (Right "hello")
Right 5
>>> traverses 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

Traverse both parts of a Bitraversable1 container with matching types.

>>> traverses bitraversed1 (pure . NE.length) ('h' :| "ello", 'w' :| "orld")
(5,5)

Obtain a Traversal1' by repeating the input forever.

repeat ≡ lists repeated

>>> take 5 $ 5 ^.. repeated
[5,5,5,5,5]

repeated :: Fold1 a a

x ^. iterated f returns an infinite Traversal1' of repeated applications of f to x.

lists (iterated f) a ≡ iterate f a

>>> take 3 $ (1 :: Int) ^.. iterated (+1)
[1,2,3]

iterated :: (a -> a) -> Fold1 a a

Transform a Traversal1' into a Traversal1' that loops over its elements repeatedly.

>>> take 7 $ (1 :| [2,3]) ^.. cycled traversed1
[1,2,3,1,2,3,1]

cycled :: Fold1 s a -> Fold1 s a

Test whether the optic matches or not.

>>> matches just (Just 2)
Right 2
>>> matches just (Nothing :: Maybe Int) :: Either (Maybe Bool) Int
Left Nothing

TODO: Document

TODO: Document

TODO: Document

TODO: Document

TODO: Document

TODO: Document

>>> collects left' (1, Left "foo") :: Either (Int8, String) String
Left (1,"foo")
>>> collects left' (1, Right "foo")
Right "foo"

TODO: Document

TODO: Document

>>> collects1 cotraversed1 ["xxx","ooo"] :: [String]
["xo","xo","xo"]

Generalizing Star of a strong Functor

Note: Every Functor in Haskell is strong with respect to (,).

This describes profunctor strength with respect to the product structure of Hask.

http://www.riec.tohoku.ac.jp/~asada/papers/arrStrMnd.pdf

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.

A strong profunctor allows the monoidal structure to pass through.

A closed profunctor allows the closed structure to pass through.

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

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