Unwrap Values from a Maybe
In the previous articles in this series, we've covered the Maybe
type to gain a general understanding, and we've seen how we can construct a Maybe
with the safe
function. Applying functions to values within the context of a Maybe
means we can perform our transformations with more confidence. At some point, we’re going to need to extract our value to use it in places where our code expects a raw value. In this article we'll see how to do that after we introduce a little bit of function composition.
Setup
Our starting code has some imports from the Crocks library, two small utilities called inc
and dbl
, and a function called incDbl
that uses the inc
and dbl
utilities to combine them into a single function.
import safe from 'crocks/Maybe/safe'
import isNumber from 'crocks/predicates/isNumber'
export const inc = (n) => n + 1
export const dbl = (n) => n * 2
const incDbl = (n) => {
const incremented = inc(n)
return dbl(incremented)
}
const result = incDbl(2)
console.log(result) // 6
Using a Maybe
If we pass a string like '2'
into incDbl
we'll end up with 42 since inc
will coerce the 1
to a string, resulting in '21'
then dbl
will coerce that '21'
to a number and double it. Let's introduce a Maybe
to avoid that sort of unintended result.
Right in the incDbl
function, we can put safe
and isNumber
to use. That means we'll need to map
over our functions instead of calling them with directly with the data since it will now be wrapped up in the Maybe
type.
import safe from 'crocks/Maybe/safe'
import isNumber from 'crocks/predicates/isNumber'
export const inc = (n) => n + 1
export const dbl = (n) => n * 2
const incDbl = (n) => {
const safeNum = safe(isNumber, n)
return safeNum.map(inc).map(dbl)
}
const result = incDbl(2)
console.log(result.toString()) // Just 6
With that, we get back a Just 6
for the number 2 as input, and a Nothing
if we pass in a non-number.
Composing The Functions
Because we're calling these two utility functions, we ended up having to map
over each of them individually. By mapping multiple times, what we end up doing is unwrapping the value from the Maybe
, invoking the function, wrapping the value again, then immediately unwrapping, invoking, and wrapping. Instead of mapping over two functions, let's create a function composition so we can reduce this down to one map
.
We'll start by importing compose
from Crocks:
import compose from 'crocks/helpers/compose'
Then we can replace the multiple map
s with a single map
over a composition of the inc
and dbl
functions.
const incDbl = (n) => {
const safeNum = safe(isNumber, n)
- return safeNum.map(inc).map(dbl)
+ return safeNum.map(compose(dbl, inc))
}
This will give us the same results, but now we only need to unwrap and rewrap the value once.
Unwrapping the Value
Now that we've added the safety of a Maybe
and used composition to avoid unnecessary steps, we need to unwrap the value so our original incDbl
function can continue to be consumed in the same way as when we started (only safer 😉).
Each Maybe
instance comes with a handy method called option
. The option
method accepts a value to be returned in the case of a Nothing
. Otherwise, option
returns the raw, unwrapped version from a Just
.
const incDbl = (n) => {
const safeNum = safe(isNumber, n)
- return safeNum.map(compose(dbl, inc))
+ return safeNum.map(compose(dbl, inc)).option(0)
}
With that, we will get a 0
for any input that results in a Nothing
and the value of calling incDbl
with any valid value.