Data.Functor.Alt

semigroupoids-1.2.6: Haskell 98 semigroupoids: Category sans id

Portability | portable
Stability | provisional
Maintainer | Edward Kmett <ekmett@gmail.com>

Data.Functor.Alt

Description

Synopsis

- class Functor f => Alt f where
  - (<!>) :: f a -> f a -> f a
  - some :: Applicative f => f a -> f [a]
  - many :: Applicative f => f a -> f [a]
- module Data.Functor.Apply

# Documentation

class Functor f => Alt f where

Laws:

     <!> is associative:             (a <!> b) <!> c = a <!> (b <!> c)
     <$> left-distributes over <!>:  f <$> (a <!> b) = (f <$> a) <!> (f <$> b)

If extended to an `Alternative` then `<!>` should equal `<|>`.

Ideally, an instance of `Alt` also satisfies the "left distributon" law of MonadPlus with respect to .:

     <.> right-distributes over <!>: (a <!> b) <.> c = (a <.> c) <!> (b <.> c)

But `Maybe`, `IO`, ``Either` a`, ``ErrorT` e m`, and `STM` satisfy the alternative "left catch" law instead:

     pure a <!> b = pure a

However, this variation cannot be stated purely in terms of the dependencies of `Alt`.

When and if MonadPlus is successfully refactored, this class should also be refactored to remove these instances.

The right distributive law should extend in the cases where the a `Bind` or `Monad` is provided to yield variations of the right distributive law:

     (m <!> n) >>- f = (m >>- f) <!> (m >>- f)
     (m <!> n) >>= f = (m >>= f) <!> (m >>= f)

Methods

(<!>) :: f a -> f a -> f a

`(|)` without a required `empty`

some :: Applicative f => f a -> f [a]

many :: Applicative f => f a -> f [a]

Instances

Alt [] |
Alt IO | This instance does not actually satisfy the (.) right distributive law It instead satisfies the Left-Catch law
Alt Maybe |
Alt Seq |
Alt IntMap |
Alt Option |
Alt NonEmpty |
Alt (Either a) |
MonadPlus m => Alt (WrappedMonad m) |
Ord k => Alt (Map k) |
(Bind f, Monad f) => Alt (MaybeT f) |
Apply f => Alt (ListT f) |
Alt f => Alt (IdentityT f) |
Alternative f => Alt (WrappedApplicative f) |
ArrowPlus a => Alt (WrappedArrow a b) |
Alt f => Alt (WriterT w f) |
Alt f => Alt (WriterT w f) |
Alt f => Alt (StateT e f) |
Alt f => Alt (StateT e f) |
Alt f => Alt (ReaderT e f) |
(Bind f, Monad f) => Alt (ErrorT e f) |
Alt f => Alt (Static f a) |
Alt f => Alt (RWST r w s f) |
Alt f => Alt (RWST r w s f) |

module Data.Functor.Apply