Documentation

Analog of Traversable over arity-1 type constructors.

This is defined in terms of mapTraverse10 for two reasons:

• First, it makes it possible to use with GeneralizedNewtypeDeriving and DerivingVia. See https://ryanglscott.github.io/2018/06/22/quantifiedconstraints-and-the-trouble-with-traversable/ for more details.
• Second, it uses fewer fmaps in some cases: when you need to re-apply a constructor tag like L1 or R1 after calling traverse10 on the payload, this would normally be an additional fmap, but with mapTraverse10 it can be fused into the underlying recursive call. Less crucially, the same trick applies when traversing multiple fields and combining them back into a product type: the first call can use mapTraverse10 to pre-apply the function, and use <*> rather than liftA2 (which is often defined as an fmap followed by a <*>).

Analog of traverse for functors over arity-1 type constructors.

Given a parametric function that takes the wrapped type m a to n a in an Applicative f, visit all contained m _s to convert from t m to t n.

m and n here play the role of a and b in the normal traverse type; that is, instead of traversing to change a Type, we're traversing to change a type constructor of kind k -> Type:

    traverse
      :: (Traversable t, Applicative f)
      => (          a   -> f  b   ) -> t a -> f (t b)
    traverse10
      :: (Traversable10 t, Applicative f)
      => (forall x. m x -> f (n x)) -> t m -> f (t n)

sequenceA for Traversable10.

This variant expects just the plain m actions at each field, and wraps the results in @Identity.

sequenceA for Traversable10.

This variant expects the composition of the Applicative being sequenced with some inner type constructor at each field.