@cprussin/option-result v1.3.0
@cprussin/option-result - v1.3.0
This package contains yet another Typescript clone of the rust Option &
Result enums.
Installing
Use the package manager of your choice to install:
- npm:
npm install --save-dev @cprussin/option-result - pnpm:
pnpm add -D @cprussin/option-result - yarn:
yarn add -D @cprussin/option-result
Usage
This library mostly implements an as-close-to-identical API to the Rust types as possible.
Example
import { Some } from "@cprussin/option-result";
Some(5)
.map((value) => value + 1)
.match({
Some: (value) => console.log(value),
None: () => console.error("There's nothing here!"),
});FAQ
Motivation
Two main reasons:
- I didn't find any existing implementations I found to be satisfactory. They either lacked the strong typing guarantees I wanted, or they were incomplete and unmaintained, or I simply didn't like their stylistic preferences. For some reason or another I wasn't happy with any of the other implementations I tried.
- It's fun. Type-safe
OptionandResultare really rewarding types to implement. If you haven't tried building them yourself, I strongly recommend it.
Why use Rust's Option and Result instead of Haskell's Maybe and Either?
I opted to implement the Rust versions of these types and not the Haskell/Purescript versions for a few reasons:
- There are no type classes in Typescript, so approximated
MaybeandEitherimplementations would have way more differences from their source versions thanOptionandResultinstances. - I love Haskell and Purescript (and other ML family languages) personally, but I also believe those to be far less approachable languages than Rust. I think the Rust versions are easier to understand and teach and the terminology is easier to grok for newcomers, at the expense of some degree of generic code. I use this library practically myself and while I value type safety, I also value approachability from developers other than myself, and I believe the Rust versions strike a better balance there than the Haskell/Purescript ones do.
- Purescript compiles to Javascript; as such I don't believe there's much value in cloning types from that language when you could just as easily write parts of your application in Purescript directly instead and not have to deal with the shortcomings of using those types in a language not designed for them.
Table of contents
Classes
Functions
Functions
Err
▸ Err\<T, E>(error): Result\<T, E>
Construct a Result containing an error value.
Type parameters
| Name | Type | Description |
|---|---|---|
T | extends Object | the type of success values |
E | extends Object | the type of the error value |
Parameters
| Name | Type | Description |
|---|---|---|
error | E | the error contained by the Result |
Returns
Result\<T, E>
a Result containing an error error
See
Defined in
None
▸ None\<T>(): Option\<T>
Construct an empty Option.
Type parameters
| Name | Type | Description |
|---|---|---|
T | extends Object | the type contained by the Option |
Returns
Option\<T>
an empty Option
See
Defined in
Ok
▸ Ok\<T, E>(value): Result\<T, E>
Construct a Result containing a success value.
Type parameters
| Name | Type | Description |
|---|---|---|
T | extends Object | the type of the value |
E | extends Object | the type of error results |
Parameters
| Name | Type | Description |
|---|---|---|
value | T | the value contained by the Result |
Returns
Result\<T, E>
a Result containing value
See
Defined in
Some
▸ Some\<T>(value): Option\<T>
Construct an Option containing a value.
Type parameters
| Name | Type | Description |
|---|---|---|
T | extends Object | the type contained by the Option |
Parameters
| Name | Type | Description |
|---|---|---|
value | T | the value contained by the Option |
Returns
Option\<T>
an Option containing value
See