Rust-like Option for TypeScript
npm i @hazae41/option
- 100% TypeScript and ESM
- No external dependencies
- Similar to Rust
-
unwrap()
for throwing -
unwrapOr()
for default value -
map()
for mapping (sync/async) -
isSome()
/isNone()
type guards -
ok()
/okOr()
for converting to Result from@hazae41/result
TLDR undefined
is too low level and often leads to ugly and repetitive design patterns or bugs
When designing a function, you often encounter the case where you can't pass undefined
.
function doSomething(text: string) {
return Buffer.from(text, "utf8").toString("base64")
}
function bigFunction(text?: string) {
// ...
doSomething(text) // what if text is undefined?
// ...
}
So you end up checking for undefined
function bigFunction(text?: string) {
// ...
if (text !== undefined) {
doSomething(text)
}
// ...
}
This is annoying if we want to get the returned value
function bigFunction(text?: string) {
// ...
if (text !== undefined) {
const text2 = doSomething(text)
}
// can't use text2
}
Checks become redundant if you need to map the value or throw an error
function bigFunction(text?: string) {
// ...
const text2 = text === undefined
? undefined
: doSomething(text)
// ...
const text3 = text2 === undefined
? undefined
: doSomethingElse(text2)
// ...
if (text3 === undefined)
throw new Error(`something is wrong`)
// use text3
}
Why not check for undefined
in the callee then?
function maybeDoSomething(text?: string) {
if (text === undefined) return
return Buffer.from(text, "utf8").toString("base64")
}
If you know your argument is NOT undefined
, it will force you to check for undefined
after the call
function bigFunction(text: string) {
// ...
const text2 = doSomething(text) // text is never undefined
// text2 can now be undefined
}
Or even worse, force you to use type assertion
function bigFunction(text: string) {
// ...
const text2 = doSomething(text) as string
// ...
}
Let's keep the original function and create an intermediary function for undefined
function maybeDoSomething(text?: string) {
if (text === undefined) return
return doSomething(text)
}
Now you have twice the amount of function in your app, and if one of them changes you have to change its intermediary function too
function bigFunction(text?: string) {
const maybeText = Option.from(text)
// ...
// you want to map it?
const maybeText2 = maybeText.mapSync(doSomething)
// ...
// you want to map it again?
const maybeText3 = maybeText2.mapSync(doSomethingElse)
// ...
// you want to quickly throw an error?
const text4 = maybeText3.unwrap() // string
// you want to throw a custom error?
const text4 = maybeText3.okOr(new Error(`Something is wrong`)).unwrap()
// you want to get a result?
const text4 = maybeText3.ok() // Result<string, Error>
// you want to get a custom result?
const text4 = maybeText3.okOr(new Error(`Something is wrong`))
// you want to come back to "string | undefined"?
const text4 = maybeText3.inner // string | undefined
// you want to do manual check?
if (maybeText3.isSome())
const text4 = maybeText3.inner // string
else
// ...
}