Control.Selective.ComposeTM

newtype ComposeTM :: forall k1 k2. (k2 -> Type) -> (k1 -> k2) -> k1 -> Typenewtype ComposeTM f g a

This newtype provides a Select instance for Compose. It "lifts" the Traversable g into the Selective f. ComposeTM does this in a way that works well when the g/inner type is like Array or Maybe, whose "effect" just involves the amount of elements, and doesn't store any extra data alongside elements, like Tuple does. More details in the documentation for the Select instance. See also ComposeT for an alternate implementation that's better suited for tuples.

Constructors

• ComposeTM (f (g a))

Instances

• Newtype (ComposeTM f g a) _
• Generic (ComposeTM f g a) _
• (Show (f (g a))) => Show (ComposeTM f g a)
• (Eq1 f, Eq1 g, Eq a) => Eq (ComposeTM f g a)
• (Eq1 f, Eq1 g) => Eq1 (ComposeTM f g)
• (Ord1 f, Ord1 g, Ord a) => Ord (ComposeTM f g a)
• (Ord1 f, Ord1 g) => Ord1 (ComposeTM f g)
• (Functor f, Functor g) => Functor (ComposeTM f g)
• (Apply f, Apply g) => Apply (ComposeTM f g)
• (Applicative f, Applicative g) => Applicative (ComposeTM f g)
• (Select f, Apply g, Traversable g) => Select (ComposeTM f g)

  This newtype provides a Select instance for Compose. It "lifts" the Traversable g into the Selective f.

  This instance works best when the traversable's "effect" is failure/nondeterminism, like Array or Maybe. It doesn't work too well in other cases, for example if g is Tuple, then if the first parameter contains a Left (requiring use of the second parameter), only the second parameter's fst value actually ends up in the result. See ComposeT for an instance that works better for types like Tuple.

• (Selective f, Applicative g, Traversable g) => Selective (ComposeTM f g)
• (Alt f, Functor g) => Alt (ComposeTM f g)
• (Plus f, Functor g) => Plus (ComposeTM f g)
• (Alternative f, Applicative g) => Alternative (ComposeTM f g)