Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

eitherMaybe :: Either () a -> Maybe a

errors-ext Control.Error.Extensions

Converts Either to Maybe. Specialization of either.
```
maybeEither . eitherMaybe = id
```
productMaybeWith :: (a -> b -> Maybe c) -> [[a]] -> [[b]] -> [[c]]

extrapolate Test.Extrapolate

Take the product of lists of tiers by a function returning a Maybe value discarding Nothing values.
productMaybeWith :: (a -> b -> Maybe c) -> [[a]] -> [[b]] -> [[c]]

extrapolate Test.Extrapolate.Core

Take the product of lists of tiers by a function returning a Maybe value discarding Nothing values.
eitherToMaybe :: Either e a -> Maybe a

from-sum Control.FromSum

Convert an Either to a Maybe. A Right value becomes Just.
```
>>> eitherToMaybe $ Right 3
Just 3
```
A Left value becomes Nothing.
```
>>> eitherToMaybe $ Left "bye"
Nothing
```
fromMaybe :: a -> Maybe a -> a

from-sum Control.FromSum

The fromMaybe function takes a default value and a Maybe value. If the Maybe is Nothing, it returns the default value; otherwise, it returns the value contained in the Maybe.
Examples
Basic usage:
```
>>> fromMaybe "" (Just "Hello, World!")
"Hello, World!"
```
```
>>> fromMaybe "" Nothing
""
```
Read an integer from a string using readMaybe. If we fail to parse an integer, we want to return 0 by default:
```
>>> import GHC.Internal.Text.Read ( readMaybe )

>>> fromMaybe 0 (readMaybe "5")
5

>>> fromMaybe 0 (readMaybe "")
0
```
fromMaybeExceptT :: forall (m :: Type -> Type) x a . Monad m => x -> Maybe a -> ExceptT x m a

from-sum Control.FromSum

Lift a Maybe to an ExceptT with a default value for the case when the Maybe is Nothing. If the Maybe is Just, then just return the value like normal:
```
>>> let justVal = Just True :: Maybe Bool

>>> fromMaybeExceptT 5 justVal :: ExceptT Int Identity Bool
ExceptT (Identity (Right True))
```
If the Maybe is Nothing, then use the default value as the error value:
```
>>> let nothingVal = Nothing :: Maybe Bool

>>> fromMaybeExceptT 5 nothingVal :: ExceptT Int Identity Bool
ExceptT (Identity (Left 5))
```

errors-ext	Control.Error.Extensions

extrapolate	Test.Extrapolate

extrapolate	Test.Extrapolate.Core

fromMaybeM :: Applicative m => m a -> Maybe a -> m a

from-sum	Control.FromSum

A monadic version of fromMaybe.

fromMaybeM nothingAction === maybe nothingAction pure

>>> fromMaybeM [] $ Just 5
[5]

>>> fromMaybeM [] Nothing
[]

fromMaybeMExceptT :: Monad m => x -> m (Maybe a) -> ExceptT x m a

from-sum	Control.FromSum

Similar to fromMaybeExceptT except the Maybe value is lifted in a Monad.

>>> let identityNothing = Identity Nothing :: Identity (Maybe Bool)

>>> fromMaybeMExceptT 5 identityNothing :: ExceptT Int Identity Bool
ExceptT (Identity (Left 5))

fromMaybeMM :: Monad m => m a -> m (Maybe a) -> m a

from-sum Control.FromSum

Similar to fromMaybeM but the Maybe argument is also a monadic value.
```
>>> fromMaybeMM [] [Just 6, Just 5]
[6,5]

>>> fromMaybeMM [] [Just 6, Nothing, Just 7]
[6,7]
```
NOTE: I don't particularly like the name of this function. If you have a suggestion for a better name, please submit a PR or issue.
fromMaybeM_ :: (Applicative m, Monoid b) => m b -> Maybe a -> m b

from-sum Control.FromSum

Similar to fromMaybeM, but only run the monadic nothingAction if the Maybe argument is Nothing. Otherwise, return pure mempty.
```
fromMaybeM_ nothingAction === maybe nothingAction (const $ pure mempty)
```
```
>>> fromMaybeM_ (putStrLn "hello" >> pure "bye") $ Just 5
""

>>> fromMaybeM_ (putStrLn "hello" >> pure "bye") Nothing
hello
"bye"
```
This can be convenient when you want to run some sort of logging function whenever a Maybe is Nothing. If you imagine the logging function is IO (), then the effective type of fromMaybeM_ becomes fromMaybeM_ :: IO () -> Maybe a -> IO (), because () has a Monoid instance, and IO, has an Applicative instance.
```
>>> fromMaybeM_ (putStrLn "hello") Nothing
hello
```

Page 269 of many | Previous | Next

Hoogle Search

Examples