Module

# Control.Selective

- Package
- purescript-selective-functors
- Repository
- artemisSystem/purescript-selective-functors

### #Selective Source

`class Selective :: (Type -> Type) -> Constraint`

`class (Applicative f, Select f) <= Selective f`

This typeclass extends `Select`

with an identity (`pure`

).
`Selective`

is an abstraction that sits between `Applicative`

and `Monad`

.

Instances must satisfy the following laws:

- Identity:
`x <*? pure identity = either identity identity <$> x`

- Distributivity:
`pure x <*? (y *> z) = (pure x <*? y) *> (pure x <*? z)`

- Monad subclass (if
`f`

is a`Monad`

):`select = selectM`

#### Instances

`Selective Array`

`Selective NonEmptyArray`

`Selective List`

`Selective NonEmptyList`

`Selective List`

`Selective NonEmptyList`

`Selective Maybe`

`Selective (Function r)`

`Selective (Either e)`

`Selective Effect`

`Selective Aff`

`Selective Identity`

`Selective (ST h)`

`Selective Lazy`

`Selective (Free f)`

`Selective (Run r)`

`(Monoid w) => Selective (Tuple w)`

`(Selective f, Selective g) => Selective (Product f g)`

`(Selective f) => Selective (IdentityT f)`

`(Selective f) => Selective (ReaderT r f)`

`(Selective f, Monoid w) => Selective (WriterT w f)`

`(Monad f, Monoid w) => Selective (RWST r w s f)`

`(Applicative f) => Selective (ContT r f)`

`(Monad f) => Selective (ExceptT e f)`

`(Monad f) => Selective (StateT s f)`

`(Monad f) => Selective (ListT f)`

`(Monad f) => Selective (MaybeT f)`

`Selective (ReaderT r f)`

`Selective (StateT s f)`

`(Monoid w) => Selective (WriterT w f)`

`(Monoid w) => Selective (RWSET r w s e f)`

- Modules
- Control.
Select - Control.
Selective - Control.
Selective. ComposeI - Control.
Selective. ComposeTM - Control.
Selective. ComposeTS - Control.
Selective. Free - Control.
Selective. Over - Control.
Selective. SelectA - Control.
Selective. SelectM - Control.
Selective. SelectTM - Control.
Selective. SelectTS - Control.
Selective. Under - Control.
Selective. Validation