Safe Haskell	None
Language	Haskell2010

Precursor.Control.Alternative

Contents

Alternative class
Utility functions

Synopsis

Alternative class

class Applicative f => Alternative f where #

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

```
some v = (:) <$> v <*> many v
```
```
many v = some v <|> pure []
```

Minimal complete definition

empty, (<|>)

Methods

empty :: f a #

The identity of <|>

(<|>) :: f a -> f a -> f a infixl 3 #

An associative binary operation

some :: f a -> f [a] #

One or more.

many :: f a -> f [a] #

Zero or more.

Instances

Alternative []
Methods empty :: [a] # (<\|>) :: [a] -> [a] -> [a] # some :: [a] -> [[a]] # many :: [a] -> [[a]] #
Alternative Maybe
Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Alternative IO
Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Alternative U1
Methods empty :: U1 a # (<\|>) :: U1 a -> U1 a -> U1 a # some :: U1 a -> U1 [a] # many :: U1 a -> U1 [a] #
Alternative Option
Methods empty :: Option a # (<\|>) :: Option a -> Option a -> Option a # some :: Option a -> Option [a] # many :: Option a -> Option [a] #
Alternative Seq
Methods empty :: Seq a # (<\|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
Alternative f => Alternative (Rec1 f)
Methods empty :: Rec1 f a # (<\|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a # some :: Rec1 f a -> Rec1 f [a] # many :: Rec1 f a -> Rec1 f [a] #
MonadPlus m => Alternative (WrappedMonad m)
Methods empty :: WrappedMonad m a # (<\|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] #
ArrowPlus a => Alternative (ArrowMonad a)
Methods empty :: ArrowMonad a a # (<\|>) :: ArrowMonad a a -> ArrowMonad a a -> ArrowMonad a a # some :: ArrowMonad a a -> ArrowMonad a [a] # many :: ArrowMonad a a -> ArrowMonad a [a] #
Alternative (Proxy *)
Methods empty :: Proxy * a # (<\|>) :: Proxy * a -> Proxy * a -> Proxy * a # some :: Proxy * a -> Proxy * [a] # many :: Proxy * a -> Proxy * [a] #
(Alternative f, Alternative g) => Alternative ((:*:) f g)
Methods empty :: (f :: g) a # (<\|>) :: (f :: g) a -> (f :: g) a -> (f :: g) a # some :: (f :: g) a -> (f :: g) [a] # many :: (f :: g) a -> (f :: g) [a] #
(Alternative f, Applicative g) => Alternative ((:.:) f g)
Methods empty :: (f :.: g) a # (<\|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a # some :: (f :.: g) a -> (f :.: g) [a] # many :: (f :.: g) a -> (f :.: g) [a] #
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)
Methods empty :: WrappedArrow a b a # (<\|>) :: WrappedArrow a b a -> WrappedArrow a b a -> WrappedArrow a b a # some :: WrappedArrow a b a -> WrappedArrow a b [a] # many :: WrappedArrow a b a -> WrappedArrow a b [a] #
Alternative f => Alternative (Alt * f)
Methods empty :: Alt * f a # (<\|>) :: Alt * f a -> Alt * f a -> Alt * f a # some :: Alt * f a -> Alt * f [a] # many :: Alt * f a -> Alt * f [a] #
(Functor m, Monad m, Error e) => Alternative (ErrorT e m)
Methods empty :: ErrorT e m a # (<\|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a # some :: ErrorT e m a -> ErrorT e m [a] # many :: ErrorT e m a -> ErrorT e m [a] #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Methods empty :: StateT s m a # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
Alternative f => Alternative (M1 i c f)
Methods empty :: M1 i c f a # (<\|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a # some :: M1 i c f a -> M1 i c f [a] # many :: M1 i c f a -> M1 i c f [a] #
(Alternative f, Alternative g) => Alternative (Product * f g)
Methods empty :: Product * f g a # (<\|>) :: Product * f g a -> Product * f g a -> Product * f g a # some :: Product * f g a -> Product * f g [a] # many :: Product * f g a -> Product * f g [a] #
(Alternative f, Applicative g) => Alternative (Compose * * f g)
Methods empty :: Compose * * f g a # (<\|>) :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a # some :: Compose * * f g a -> Compose * * f g [a] # many :: Compose * * f g a -> Compose * * f g [a] #

(<|>) :: Alternative f => forall a. f a -> f a -> f a #

An associative binary operation

empty :: Alternative f => forall a. f a #

The identity of <|>

some :: Alternative f => forall a. f a -> f [a] #

One or more.

many :: Alternative f => forall a. f a -> f [a] #

Zero or more.

Utility functions

optional :: Alternative f => f a -> f (Maybe a) #

One or none.

afilter :: (Monad m, Alternative m) => (a -> Bool) -> m a -> m a Source #

A generalized version of filter, which works on anything which is both a Monad and Alternative.

\(Blind p) xs -> filter p xs === afilter p xs

asum :: (Foldable t, Alternative f) => t (f a) -> f a #

The sum of a collection of actions, generalizing concat.

guard :: Alternative f => Bool -> f () #

guard b is pure () if b is True, and empty if b is False.

ensure :: Alternative f => (a -> Bool) -> a -> f a Source #

ensure allows you to attach a condition to something

eitherA :: Alternative f => f a -> f b -> f (Either a b) Source #

eitherA is especially useful for parsers.

toAlt :: (Alternative f, Foldable t) => t a -> f a Source #

Convert any Foldable to an Alternative

mapAlt :: (Monad m, Alternative m, Foldable f) => (a -> f b) -> m a -> m b Source #

Map a function over a monad, and concat the results. This is a generalized form of the function mapMaybe.