Control.Select

class Select :: (Type -> Type) -> Constraintclass (Apply f) <= Select f  where

Select is an abstraction that sits between Apply and Bind.

Instances must satisfy the following law:

• Associativity:

  x <*? (y <*? z) = ((map Right <$> x) <*? (f <$> y)) <*? uncurry z
  where
  f (Left y) x = Tuple y x
  f (Right y) x = y x

Members

• select :: forall a b. f (Either a b) -> f (a -> b) -> f b

Instances

• Select Array
• Select NonEmptyArray
• Select List
• Select NonEmptyList
• Select List
• Select NonEmptyList
• Select Maybe
• Select (Function r)
• Select (Either e)
• Select Effect
• Select Aff
• Select Identity
• Select (ST h)
• Select Lazy
• Select (Free f)
• Select (Run r)
• (Semigroup w) => Select (Tuple w)
• (Select f, Select g) => Select (Product f g)
• (Select f) => Select (IdentityT f)
• (Select f) => Select (ReaderT r f)
• (Select f, Semigroup w) => Select (WriterT w f)
• (Monad f, Monoid w) => Select (RWST r w s f)
• (Apply f) => Select (ContT r f)
• (Monad f) => Select (ExceptT e f)

  This instance requires the inner type to be a Monad, because the Apply instance requires it.

• (Monad f) => Select (StateT s f)

  This instance requires the inner type to be a Monad, because the Apply instance requires it.

• (Monad f) => Select (ListT f)

  This instance requires the inner type to be a Monad, because the Apply instance requires it.

• (Monad f) => Select (MaybeT f)

  This instance requires the inner type to be a Monad, because the Apply instance requires it.

• Select (ReaderT r f)
• Select (StateT s f)
• (Monoid w) => Select (WriterT w f)
• (Monoid w) => Select (RWSET r w s e f)

Operator alias for Control.Select.select (left-associative / precedence 4)

selectM :: forall @m @a @b. Monad m => m (Either a b) -> m (a -> b) -> m b

select implemented in terms of bind and pure

selectTM :: forall @t @a @b. Traversable t => t (Either a b) -> t (a -> b) -> t b

select implemented in terms of sequence. With this implementation, depending on the Either in the first argument, the first or the second effect will be executed, but never both. Traversable allows us to inspect the Either in the first parameter without including its effect in the result. This implementation is well suited for array-like traversables. (i.e. potentially containing more than one element)

selectTS :: forall @f @a @b. Traversable f => Apply f => f (Either a b) -> f (a -> b) -> f b

select implemented in terms of sequence and apply. This implementation uses apply to keep the effects of the first parameter when it is a Left, unlike selectTM. This implementation is well suited for tuple-like traversables (i.e. containing one or fewer elements)

selectA :: forall @f @a @b. Apply f => f (Either a b) -> f (a -> b) -> f b

select implemented in terms of apply (both effects are always executed)

applyS :: forall @f @a @b. Select f => f (a -> b) -> f a -> f b

apply implemented in terms of select

whenS :: forall @f. Select f => f Boolean -> f Unit -> f Unit

Execute the second action if the first action returns true

unlessS :: forall @f. Select f => f Boolean -> f Unit -> f Unit

Execute the second action if the first action returns false

branch :: forall @f @a @b @c. Select f => f (Either a b) -> f (a -> c) -> f (b -> c) -> f c

Execute either the second or the third action, depending on the result of the first

ifS :: forall @f @a. Select f => f Boolean -> f a -> f a -> f a

If the first action is true, execute the second action, otherwise the third

orS :: forall @f. Select f => f Boolean -> f Boolean -> f Boolean

Short-circuiting or

Operator alias for Control.Select.orS (right-associative / precedence 2)

andS :: forall @f. Select f => f Boolean -> f Boolean -> f Boolean

Short-circuiting and

Operator alias for Control.Select.andS (right-associative / precedence 3)

any1S :: forall @t @f. Select f => Foldable1 t => t (f Boolean) -> f Boolean

Short-circuiting any

all1S :: forall @t @f. Select f => Foldable1 t => t (f Boolean) -> f Boolean

Short-circuiting all

fromMaybeS :: forall @f @a. Select f => f a -> f (Maybe a) -> f a

If the second action is Nothing, run and return the first

whileS :: forall @f. Lazy (f Unit) => Select f => f Boolean -> f Unit

Repeat an action until it returns true