Safe Haskell | None |
---|---|
Language | Haskell2010 |
This library fills a bunch of important niches in Elm. A Maybe can help you with optional arguments, error handling, and records with optional fields.
Synopsis
- data Maybe a
- withDefault :: a -> Maybe a -> a
- map :: (a -> b) -> Maybe a -> Maybe b
- map2 :: (a -> b -> value) -> Maybe a -> Maybe b -> Maybe value
- map3 :: (a -> b -> c -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe value
- map4 :: (a -> b -> c -> d -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe d -> Maybe value
- map5 :: (a -> b -> c -> d -> e -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe d -> Maybe e -> Maybe value
- andThen :: (a -> Maybe b) -> Maybe a -> Maybe b
Definition
The Maybe
type encapsulates an optional value. A value of type
either contains a value of type Maybe
aa
(represented as
),
or it is empty (represented as Just
aNothing
). Using Maybe
is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error
.
The Maybe
type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing
. A richer
error monad can be built using the Either
type.
Instances
Monad Maybe | Since: base-2.1 |
Functor Maybe | Since: base-2.1 |
MonadFail Maybe | Since: base-4.9.0.0 |
Defined in Control.Monad.Fail | |
Applicative Maybe | Since: base-2.1 |
Foldable Maybe | Since: base-2.1 |
Defined in Data.Foldable fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Traversable Maybe | Since: base-2.1 |
ToJSON1 Maybe | |
Defined in Data.Aeson.Types.ToJSON liftToJSON :: (a -> Value) -> ([a] -> Value) -> Maybe a -> Value # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding # | |
FromJSON1 Maybe | |
Alternative Maybe | Since: base-2.1 |
MonadPlus Maybe | Since: base-2.1 |
Eq1 Maybe | Since: base-4.9.0.0 |
Ord1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Read1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Show1 Maybe | Since: base-4.9.0.0 |
MonadThrow Maybe | |
Defined in Control.Monad.Catch | |
Hashable1 Maybe | |
Defined in Data.Hashable.Class | |
MonadBaseControl Maybe Maybe | |
(Selector s, GToJSON' enc arity (K1 i (Maybe a) :: Type -> Type), KeyValuePair enc pairs, Monoid pairs) => RecordToPairs enc pairs arity (S1 s (K1 i (Maybe a) :: Type -> Type)) | |
Defined in Data.Aeson.Types.ToJSON | |
Lift a => Lift (Maybe a :: Type) | |
(Selector s, FromJSON a) => RecordFromJSON' arity (S1 s (K1 i (Maybe a) :: Type -> Type)) | |
Defined in Data.Aeson.Types.FromJSON | |
Eq a => Eq (Maybe a) | Since: base-2.1 |
Ord a => Ord (Maybe a) | Since: base-2.1 |
Read a => Read (Maybe a) | Since: base-2.1 |
Show a => Show (Maybe a) | Since: base-2.1 |
Generic (Maybe a) | Since: base-4.6.0.0 |
Semigroup a => Semigroup (Maybe a) | Since: base-4.9.0.0 |
Semigroup a => Monoid (Maybe a) | Lift a semigroup into Since 4.11.0: constraint on inner Since: base-2.1 |
Hashable a => Hashable (Maybe a) | |
Defined in Data.Hashable.Class | |
ToJSON a => ToJSON (Maybe a) | |
Defined in Data.Aeson.Types.ToJSON | |
FromJSON a => FromJSON (Maybe a) | |
MonoFunctor (Maybe a) | |
MonoFoldable (Maybe a) | |
Defined in Data.MonoTraversable ofoldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m # ofoldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # ofoldl' :: (a0 -> Element (Maybe a) -> a0) -> a0 -> Maybe a -> a0 # otoList :: Maybe a -> [Element (Maybe a)] # oall :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # oany :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # olength64 :: Maybe a -> Int64 # ocompareLength :: Integral i => Maybe a -> i -> Ordering # otraverse_ :: Applicative f => (Element (Maybe a) -> f b) -> Maybe a -> f () # ofor_ :: Applicative f => Maybe a -> (Element (Maybe a) -> f b) -> f () # omapM_ :: Applicative m => (Element (Maybe a) -> m ()) -> Maybe a -> m () # oforM_ :: Applicative m => Maybe a -> (Element (Maybe a) -> m ()) -> m () # ofoldlM :: Monad m => (a0 -> Element (Maybe a) -> m a0) -> a0 -> Maybe a -> m a0 # ofoldMap1Ex :: Semigroup m => (Element (Maybe a) -> m) -> Maybe a -> m # ofoldr1Ex :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) # ofoldl1Ex' :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) # headEx :: Maybe a -> Element (Maybe a) # lastEx :: Maybe a -> Element (Maybe a) # unsafeHead :: Maybe a -> Element (Maybe a) # unsafeLast :: Maybe a -> Element (Maybe a) # maximumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) # minimumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) # | |
MonoTraversable (Maybe a) | |
MonoPointed (Maybe a) | |
Validity a => Validity (Maybe a) | A Maybe thing is valid if the thing inside is valid or it's nothing
It makes sense to assume that |
Defined in Data.Validity validate :: Maybe a -> Validation # | |
Pretty a => Pretty (Maybe a) | |
Defined in Text.PrettyPrint.Annotated.WL | |
SingKind a => SingKind (Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics type DemoteRep (Maybe a) | |
Generic1 Maybe | Since: base-4.6.0.0 |
SingI ('Nothing :: Maybe a) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
SingI a2 => SingI ('Just a2 :: Maybe a1) | Since: base-4.9.0.0 |
Defined in GHC.Generics | |
type StM Maybe a | |
Defined in Control.Monad.Trans.Control | |
type Rep (Maybe a) | |
Defined in GHC.Generics | |
type Element (Maybe a) | |
Defined in Data.MonoTraversable | |
type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
data Sing (b :: Maybe a) | |
type Rep1 Maybe | |
Common Helpers
withDefault :: a -> Maybe a -> a Source #
Provide a default value, turning an optional value into a normal
value. This comes in handy when paired with functions like
get
which gives back a Maybe
.
>>> withDefault 100 (Just 42) 42 >>> withDefault 100 Nothing 100 >>> withDefault "unknown" (Dict.get "Tom" Dict.empty) "unknown"
Note: This can be overused! Many cases are better handled by a case
expression. And if you end up using withDefault
a lot, it can be a good sign
that a custom type
will clean your code up quite a bit!
map :: (a -> b) -> Maybe a -> Maybe b Source #
Transform a Maybe
value with a given function:
>>> map sqrt (Just 9) Just 3 >>> map sqrt Nothing Nothing >>> map sqrt (String.toFloat "9") Just 3 >>> map sqrt (String.toFloat "x") Nothing
map2 :: (a -> b -> value) -> Maybe a -> Maybe b -> Maybe value Source #
Apply a function if all the arguments are Just
a value.
>>> map2 (+) (Just 3) (Just 4) Just 7 >>> map2 (+) (Just 3) Nothing Nothing >>> map2 (+) Nothing (Just 4) Nothing >>> map2 (+) (String.toInt "1") (String.toInt "123") Just 124 >>> map2 (+) (String.toInt "x") (String.toInt "123") Nothing >>> map2 (+) (String.toInt "1") (String.toInt "1.3") Nothing
map4 :: (a -> b -> c -> d -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe d -> Maybe value Source #
map5 :: (a -> b -> c -> d -> e -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe d -> Maybe e -> Maybe value Source #
Chaining Maybes
andThen :: (a -> Maybe b) -> Maybe a -> Maybe b Source #
Chain together many computations that may fail. It is helpful to see an equivalent definition:
andThen :: (a -> Maybe b) -> Maybe a -> Maybe b andThen callback maybe = case maybe of Just value -> callback value Nothing -> Nothing
This means we only continue with the callback if things are going well. For example, say you need to parse some user input as a month:
parseMonth :: String -> Maybe Int parseMonth userInput = String.toInt userInput |> andThen toValidMonth toValidMonth :: Int -> Maybe Int toValidMonth month = if 1 <= month && month <= 12 then Just month else Nothing
In the parseMonth' function, if 'String.toInt
produces Nothing
(because
the userInput
was not an integer) this entire chain of operations will
short-circuit and result in Nothing
. If toValidMonth
results in
Nothing
, again the chain of computations will result in Nothing
.