Usual disclaimer - I don’t know Haskell at all. What follows is my rambling experimentation with the
Haskell has a useful type called
Maybe. F# and probably most other functional languages have something similar. Even C# has Nullable
Maybe is a parameterised or polymorphic type that represents that we possibly have a value of the type parameter. So
Maybe Int means maybe we have an
Int, maybe we don’t (ie we have Nothing).
Because Haskell doesn’t allow
null values we might use
Maybe for a function that returns its input if the input is a positive number.
giveIfEvan :: Int -> Maybe Int giveIfEvan n = if n `mod` 2 == 0 then Just n else Nothing
Maybe is a monad, which, to me, means primarily that it provides a function to convert from a
Maybe of some type to a
Maybe of some other type (
>>= :: Maybe a -> Maybe b).
Imagine I want a function that given a
Maybe Int adds 1 to the value (if there is a value). One terrible way to write this is:
addOne :: Maybe Int -> Maybe Int addOne n = if isJust n then Just (fromJust n + 1) else Nothing
or with pattern matching:
addOne :: Maybe Int -> Maybe Int addOne (Just a) = Just (a + 1) addOne Nothing = Nothing
Maybe is a monad we can use do notation:
addOne n = do v <- n return (v + 1)
The benefit here is that
addOne handles the nothing case without an explicit conditional.
If you don’t mind using a lambda you can use the de-sugared version of do
addOne n = n >>= \v -> return (v + 1)
Or instead of a lambda we could define an extra function:
increment :: Int -> Maybe Int increment v = return (v + 1) addOne :: Maybe Int -> Maybe Int addOne n = n >>= increment
Here is a complete program. Try changin the 8 to an odd number to see the nothing case.
import Data.Maybe giveIfEvan :: Int -> Maybe Int giveIfEvan n = if n `mod` 2 == 0 then Just n else Nothing addOne :: Maybe Int -> Maybe Int addOne n = do v <- n return (v + 1) main = do return (addOne $ giveIfEvan 8)