The Prostrong-flavored iso; for the profunctor-class-flavored encoding see PIso.

A traversal in the profunctor-class-flavored encoding (cf. PIso), used by the GHC.Generics combinators below. Equivalent to Traversal via toPTraversal and fromPTraversal.

A full traversal in the profunctor-class encoding: distributes any profunctor carrying both distributive strength and product strength -- exactly the constraint travP demands. This is the Traversal analog of PTraversal, which drops the product strength (all it needs for a MonoidalTraversal). Equivalent to Traversal via toPTraversalFull and traversal.

An algebraic lens: like a Lens, but put is allowed to combine information monadically -- get :: s ~> a, put :: m % s ** b ~> t -- rather than only ever seeing the last s.

Create an isomorphism from two arrows, at any optic constraint. Note that this doesn't enforce that the arrows are actually inverses!

The same iso builds a Iso, a PIso, a PTraversal, ... depending on the type it is used at; since c is only determined by the use site, bind the result with a type signature.

Build a monoidal lens from its two legs and a chosen comonoidal residual m.

Build an AffineTraversal by composing a Lens with a Prism: focus a field with the lens, then match a case of that field with the prism. There is no from-legs builder for a bare affine traversal (its witness only ever arises by composition), so this is the design-aligned way to make one -- the same convert (l % p) idiom the test suite uses.

The canonical/atomic grate constructor: the residual is the self-referential s ~~> a (the "logarithm" of the get side), whose own get-map m ~> (s ~~> a) trivializes to id once m is fixed to be exactly s ~~> a. That residual must be a comonoid; in a CopyDiscard category every object is.

Build a glass from its single leg. The residuals are the whole source and the "logarithm" s ~~> a, so the witness is the lens witness at s composed with the grate witness at s ~~> a.

Build an n-ary power grate from a tensor-power decomposition of s and recomposition of t.

Build a cotraversal from its legs through an applicative functor, given as a representable StrongDistributiveProfunctor p.

Build a kaleidoscope from the same legs.

Build an algebraic lens from get and a monadic put; the residual is the free algebra m % s itself (which must be a comonoid, as must s to be kept alongside its focus).

Build a classifying lens from get and a classify :: l % s ** b ~> t; the residual is the free algebra l % s, e.g. the list of sources.

Build a tracer from its two legs and a chosen residual m: m ** s ~> a decomposes the source (given the residual), b ~> m ** t rebuilds the target and produces the residual to feed back.

Build a traversal from a Traversable (representable) functor t: it focuses every element the functor holds. This is the one weak-flavor builder that is genuinely primitive -- a Traversables traversal is not reachable by convert from any single stronger optic. The witness is t itself paired with RepCostar t (see TravFl above); the two legs are the representable universal repUniv and the identity RepCostar.

Build a Traversal from its van-Laarhoven / profunctor-class form, by instantiating the rank-2 function at the generic carrier ExOptic TravFl a b (a StrongDistributiveProfunctor and Strong ProdAction, unlike ExOptic MonTravFl a b, since TravFl contains the product-lens witness). The Traversal analog of fromPTraversal.

View through any optic that can act as a getter, in either encoding: run it at its witness pair (ExOptic GetterFl, via withLegs) and read the get leg off with getP.

Review through any optic that can act as a review, in either encoding: getP on the flipped witness pair.

Preview through any optic that can act as an affine fold, in either encoding: run it at its witness pair (ExOptic AffineFoldFl, via withLegs) and apply previewP.

Match through any optic that can act as an affine traversal, in either encoding: returns the focus (rgt) when it matches, or a reconstructed t (lft) when it does not. This is the AffineTraversal eliminator, refining preview (which forgets t). Runs the optic at its witness pair (ExOptic AffineTravFl, via withLegs) and applies affineMatch.

Map over any optic that can act as a setter, in either encoding: run it at its witness pair (ExOptic SetterFl, via withLegs) and apply overP.

Fold through any optic that can act as a fold, in either encoding: run it at its witness pair (ExOptic FoldFl, via withLegs) and apply foldMapP.

Traverse: distribute any StrongDistributiveProfunctor -- not merely a Star f (the Hask van-Laarhoven shape) -- through any optic that is at least a Traversal. Works for an arbitrary profunctor carrier by handing it to travP, rather than relying on a per-carrier Prostrong w p bridge (which could only ever cover specific carrier heads).

The optic is accepted in any encoding: the constraint asks the optic's class to hold for the generic carrier ExOptic TravFl a b, which a Prostrong-flavored optic discharges via forall p q. w p q => Sub TravFl p q, a (%)-composite one conjunct at a time, and a profunctor-class one (PTraversalFull) through the carrier's by-generator instances.

Like traverseOf, but for a MonoidalTraversal -- distributes any StrongDistributiveProfunctor with no product-strength requirement on the carrier. Every non-lens traversal (prism, Traversable functor, ...) is a monoidal traversal, so this accepts carriers like Writer w that are tensor-strong but not product-strong.

Accepts any encoding (cf. traverseOf): a PTraversal works directly, as does a (%)-composite.

Distribute any MonoidalProfunctor through a power grate (or any stronger optic). At the hom (~>) this is over; at an applicative Star f the foci are combined through f.

Accepts any encoding (cf. traverseOf), including (%)-composites.

Pass a Cotraversable carrier through a cotraversal (or any stronger optic, in any encoding, (%)-composites included).

Act on a Kaleidoscopic carrier through a kaleidoscope (or any stronger optic, in any encoding, (%)-composites included). At Costar [] this is the literature's aggregation operator >-: from [a] -> b to [s] -> t.

Zip two sources through a Kaleidoscope (or any stronger optic, a Grate in particular, in any encoding): combine the foci pairwise. This is kaleidoscopeOf at the carrier RepCostar (Pow 2), the costar of the binary tensor power -- a binary combination (a ** a) ~> b of foci, which the optic's applicative lifts by liftA2.

Classify a monadic computation of s's through an AlgebraicLens (or any stronger optic, in any encoding), given a replacement focus b -- generalizing "set" to combine every s the computation might produce (via its residual's Algebra) rather than only ever seeing the last one. The focus a is discarded under the monad, hence must be a comonoid.

Distribute any Costrong profunctor through a tracer (or any stronger optic). At the hom this is over, computing the feedback loop through the residual.

Accepts any encoding (cf. traverseOf): a PTracer works directly, as does a (%)-composite.

Eliminate any iso-flavored optic to its two legs, in either encoding -- including the profunctor-class-flavored PIso and reversed (re) isos.

Eliminate any optic that is at least an iso and at most a lens to its two legs, in either encoding: run it at its witness pair (ExOptic LensFl, via withLegs) and read the legs off with getP and putP.

Eliminate any optic that is at least an iso and at most a monoidal lens to its two legs, recovering the existential residual m together with its comonoid structure: run it at its witness pair (ExOptic MonLensFl, via withLegs) and read the legs off with withMonLensP.

Eliminate any optic that is at least an iso and at most a prism to its two legs, in either encoding: run it at its witness pair (ExOptic PrismFl, via withLegs) and read the legs off with matchingP and getP on the flipped pair (a prism's build leg is a getter read backwards).

Eliminate any grate-flavored optic to its zipping function, in either encoding: run it at its witness pair (ExOptic GrateFl, via withLegs) and read the zipper off with zipWithP.

Eliminate any glass-flavored optic (a lens, a grate, or a composite of both, in either encoding) to its single leg.

View the focus of a concrete, Type-level optic.

Review through a concrete, Type-level optic.

Preview the focus of a concrete, Type-level optic (a getter that might not match).

classifyOf for a Haskell monad, curried: optic .? b $ fs.

Named version of (.~).

Apply a function through a concrete, Type-level Setter.

Replace the focus/foci of a concrete, Type-level Setter with a constant value.

Unfold t from a Comonoid seed cm through the b-foci. It is foldMapOf run in OPPOSITE k, where Monoid becomes Comonoid and consumption becomes construction. (Inhabitable once the flavor's Prostrong transports through OP.)

Compose two optics, of any (possibly different) flavors or encodings. The composite's constraint is the conjunction :&&:, so the composite is automatically usable at exactly the meet of the two flavors' capabilities: a lens composed with a prism previews, folds, traverses and sets, but no longer views or reviews. Use convert to name the composite at a single flavor for storage, e.g. convert (l % p) :: AffineTraversal s t a b.

Convert an optic to a chosen flavor w, by running it at its existential encoding ExOptic w a b and wrapping the resulting witness pair back around the carrier: this works for any input encoding. A Prostrong-flavored optic converts along the subtyping lattice (via the bridge instance of ExOptic; an invalid conversion fails with Could not deduce (w p q) for the missing superclass), a :&&:-composite converts when both conjuncts do, and a profunctor-class-flavored optic converts when ExOptic w a b has an instance of its class -- which it does for every class whose generating witnesses w contains (cf. fromPIso, fromPTraversal, fromPTracer).

Consumers accept any sufficiently strong optic directly, so this is rarely needed to use an optic; but constructors and % return their exact type monomorphically, so it is the way to store an optic at a weaker type, e.g. convert (lens f g) :: Traversal' s a.

An Eilenberg-Moore algebra for the monad m -- a representable Promonad on k, acting as the functor m % - (Proarrow.Promonad): a structure map m % a ~> a, coherent with the monad's unit and multiplication. The free algebras m % s are the ones an algebraic lens is built from (algebraicLens).

There are deliberately no instances for the unit or for products of algebras, and there cannot be: Unit and (**) are type families, which may not head an instance. That is why withAlgP passes the structure map as a value -- the composition instance pairs two algebras with unparRep and the identity witness supplies the unit one with unpar0Rep, neither needing an Algebra instance. A witness pair whose residual is the unit is the identity optic up to the unitors, so nothing is lost.

Half of the equivalence between the two traversal encodings: eliminate the existential witnesses with travP at the caller's profunctor.

Eliminate a Traversal to its profunctor-class form (the analog of toPTraversal): run travP at the caller's profunctor.

The other half of the equivalence between the encodings: instantiate the profunctor-class-flavored traversal at the generic carrier ExOptic MonTravFl a b, which is an SDP by the by-generator instances above. Because its tensor strength comes from the tensor-action witness Rep (ActionAt Tensor _) (not a product lens), this needs no Cartesian (tensor = product), only CopyDiscard (a discard a ~> Unit for the residual) -- which is exactly what the coproduct-prism witness already demanded -- enabling e.g. the biproduct categories Mat and FinRel (but not LINEAR, which cannot discard). A Traversal is recovered for free wherever one is needed, since MonTravFl@ is a subflavor of TravFl.