Convenience functions for Maybe
.
Work with 1 Maybe
isJust : Maybe a -> Basics.Bool
isJust (Just 42)
--> True
isJust (Just [])
--> True
isJust Nothing
--> False
isNothing : Maybe a -> Basics.Bool
isNothing (Just 42)
--> False
isNothing (Just [])
--> False
isNothing Nothing
--> True
join : Maybe (Maybe a) -> Maybe a
Flattens nested Maybe
s
join (Just (Just 1))
--> Just 1
join (Just Nothing)
--> Nothing
join Nothing
--> Nothing
filter : (a -> Basics.Bool) -> Maybe a -> Maybe a
Keep the Maybe
only if the predicate function passes
filter (\v -> v == 1) (Just 1)
--> Just 1
filter (\v -> v == 2) (Just 1)
--> Nothing
filter (\v -> v == 1) Nothing
--> Nothing
Maybe
withDefaultLazy : (() -> a) -> Maybe a -> a
Lazy version of Maybe.withDefault.
It will only calculate the default if needed.
Examples:
withDefaultLazy (\() -> 2 + 2) Nothing
--> 4
withDefaultLazy (\() -> Debug.todo "Expensive calculation") (Just 4)
--> 4
unwrap : b -> (a -> b) -> Maybe a -> b
Like using a case
.
Give a function that says what to do if the input is Just
,
and a value to use if the input is Nothing
.
These are all equivalent:
unwrap default f maybeX
maybeX
|> Maybe.map f
|> Maybe.withDefault default
case maybeX of
Just x ->
f x
Nothing ->
default
Except that unlike a case
, the default value for unwrap
is always computed.
If your default value is expensive to compute, use the lazy unpack
instead.
Examples:
unwrap 0 String.length Nothing
--> 0
unwrap 0 String.length (Just "abc")
--> 3
unpack : (() -> b) -> (a -> b) -> Maybe a -> b
Like unwrap
, but the default value is lazy,
and will only be computed if the Maybe
is Nothing
.
unpack (\() -> 0) String.length Nothing
--> 0
unpack (\() -> 0) String.length (Just "abc")
--> 3
unpack (\() -> default) f maybeX
is equivalent to
case maybeX of
Just x ->
f x
Nothing ->
default
Take the first value that's present
or : Maybe a -> Maybe a -> Maybe a
Returns the first value that is present, like the boolean ||
.
Both values will be computed. There is no short-circuiting.
If your second argument is expensive to calculate and you need short circuiting, use orLazy
instead.
or (Just 4) (Just 5)
--> Just 4
or (Just 4) Nothing
--> Just 4
or Nothing (Just 5)
--> Just 5
or Nothing Nothing
--> Nothing
Advanced functional programmers will recognize this as the
implementation of mplus
for Maybe
s from the MonadPlus
type
class.
orElse : Maybe a -> Maybe a -> Maybe a
Piping-friendly version of or
.
Just 5
|> orElse (Just 4)
--> Just 5
orElse (Just 4) (Just 5)
--> Just 5
List.head []
|> orElse (List.head [ 4 ])
--> Just 4
orList : List (Maybe a) -> Maybe a
Returns the first value that is present.
All values will be computed.
If your arguments are expensive to calculate, use orListLazy
instead.
orList
[ Nothing
, Just 1
, Just 2
]
--> Just 1
orList
[ List.head []
, String.toInt ""
]
--> Nothing
orList []
--> Nothing
orLazy : Maybe a -> (() -> Maybe a) -> Maybe a
Lazy version of or
.
The second argument will only be evaluated if the first argument is Nothing
.
orLazy (Just 4) (\() -> Debug.todo "Expensive calculation")
--> Just 4
orElseLazy : (() -> Maybe a) -> Maybe a -> Maybe a
Lazy version of orElse
.
Piping-friendly version of orLazy
.
The first argument will only be evaluated if the second argument is Nothing
.
Just 4
|> orElseLazy (\() -> Debug.todo "Expensive calculation")
--> Just 4
orListLazy : List (() -> Maybe a) -> Maybe a
Lazy version of orList
Stops calculating new values after the first match
orListLazy
[ \() -> Nothing
, \() -> Just 1
, \() -> Debug.todo "Expensive calculation"
]
--> Just 1
oneOf : List (a -> Maybe b) -> a -> Maybe b
Try a list of functions against a value. Return the value of the first call that succeeds (returns Just
).
type UserInput
= FloatInput Float
| IntInput Int
| UnknownInput
"5.6"
|> oneOf
[ String.toInt >> Maybe.map IntInput
, String.toFloat >> Maybe.map FloatInput
]
|> Maybe.withDefault UnknownInput
--> FloatInput 5.6
Maybe
svalues : List (Maybe a) -> List a
Take all the values that are present, throwing away any Nothing
s.
Equivalent to List.filterMap identity
.
values [ Just 1, Nothing, Just 2 ]
--> [ 1, 2 ]
combine : List (Maybe a) -> Maybe (List a)
If every Maybe
in the list is present, return all of the values unwrapped.
If there are any Nothing
s, the whole function fails and returns Nothing
.
combine []
--> Just []
combine [ Just 1, Just 2, Just 3 ]
--> Just [ 1, 2, 3 ]
combine [ Just 1, Nothing, Just 3 ]
--> Nothing
traverse : (a -> Maybe b) -> List a -> Maybe (List b)
Like combine
, but map a function over each element of the list first.
If every function call succeeds (returns Just
), traverse
will return a list.
If any function call fails (returns Nothing
), traverse
will return Nothing
.
combine
is equivalent to traverse identity
.
traverse (\x -> Just (x * 10)) [ 1, 2, 3, 4, 5 ]
--> Just [ 10, 20, 30, 40, 50 ]
traverse List.head [ [1], [2, 3], [] ]
--> Nothing
combineArray : Array (Maybe a) -> Maybe (Array a)
Like combine
,
but works on Array
instead of List
.
traverseArray : (a -> Maybe b) -> Array a -> Maybe (Array b)
Like traverse
,
but works on Array
instead of List
.
toList : Maybe a -> List a
A Maybe
is a lot like a list that can only be length 0 or 1.
Returns a singleton list if the value is present, and an empty list it's missing.
toList Nothing
--> []
toList (Just 1)
--> [ 1 ]
toArray : Maybe a -> Array a
Like toList
, but returns a singleton or empty Array
.
import Array
toArray Nothing
--> Array.fromList []
toArray (Just 1)
--> Array.fromList [ 1 ]
cons : Maybe a -> List a -> List a
Add an item to a list only if it's a Just
.
cons (Just 1) [ 2, 3 ]
--> [ 1, 2, 3 ]
cons Nothing [2, 3 ]
--> [ 2, 3 ]
These functions are just like andThen
, except they take multiple arguments.
All arguments must be Just
and the function must return a Just
for the result to be Just
.
If you need a version of andThenN
that takes more than 4 arguments, you can chain together andMap
calls in a pipeline.
andThen2 : (a -> b -> Maybe value) -> Maybe a -> Maybe b -> Maybe value
import Array exposing (Array)
array : Array Int
array = Array.fromList [1,2,3]
andThen2 Array.get (Just 1) (Just array)
--> Just 2
andThen2 Array.get Nothing (Just array)
--> Nothing
andThen2 Array.get (Just 1) Nothing
--> Nothing
andThen2 Array.get (Just 4) (Just array)
--> Nothing
andThen3 : (a -> b -> c -> Maybe value) -> Maybe a -> Maybe b -> Maybe c -> Maybe value
andThen4 : (a -> b -> c -> d -> Maybe value) -> Maybe a -> Maybe b -> Maybe c -> Maybe d -> Maybe value
andMap : Maybe a -> Maybe (a -> b) -> Maybe b
If both a function and a value are present, apply the function to the value.
If either argument is Nothing
, return Nothing
.
Just ((+) 2)
|> andMap (Just 3)
--> Just 5
Nothing
|> andMap (Just 3)
--> Nothing
Just ((+) 2)
|> andMap Nothing
--> Nothing
This can be used to do Maybe.mapN
or andThenN
for any number of arguments.
-- map4
Just (\a b c d -> a + b + c + d )
|> andMap (Just 1)
|> andMap (Just 2)
|> andMap (Just 4)
|> andMap (Just 8)
--> Just 15
-- andThen4
Just (\a b c d -> Just (a + b + c + d ))
|> andMap (Just 1)
|> andMap (Just 2)
|> andMap (Just 4)
|> andMap (Just 8)
|> join
--> Just 15
Advanced functional programmers will recognize this as the implementation of <*>
for Maybe
s from the Applicative
typeclass.
next : Maybe a -> Maybe b -> Maybe b
Take two Maybe
values. If the first one equals Nothing
, return Nothing
. Otherwise return the second value.
next (Just 1) (Just 2)
--> Just 2
next Nothing (Just 2)
--> Nothing
next (Just 1) Nothing
--> Nothing
Advanced functional programmers will recognize this as the implementation of *>
for Maybe
s from the Applicative
typeclass.
prev : Maybe a -> Maybe b -> Maybe a
Take two Maybe
values. If the second one equals Nothing
, return Nothing
. Otherwise return the first value.
prev (Just 1) (Just 2)
--> Just 1
prev Nothing (Just 2)
--> Nothing
prev (Just 1) Nothing
--> Nothing
Advanced functional programmers will recognize this as the implementation of <*
for Maybe
s from the Applicative
typeclass.