This package contains yet another Typescript clone of the rust Option & Result enums.

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

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!"),
  });

Two main reasons:

1. 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.
2. It's fun. Type-safe Option and Result are really rewarding types to implement. If you haven't tried building them yourself, I strongly recommend it.

I opted to implement the Rust versions of these types and not the Haskell/Purescript versions for a few reasons:

1. There are no type classes in Typescript, so approximated Maybe and Either implementations would have way more differences from their source versions than Option and Result instances.
2. 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.
3. 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.

• Option
• Result

• Err
• None
• Ok
• Some

▸ Err<T, E>(error): Result<T, E>

Construct a Result containing an error value.

Result<T, E>

a Result containing an error error

See

• Result.Ok
• Result.wrap
• Result.wrapAsync

result.ts:598

▸ None<T>(): Option<T>

Construct an empty Option.

Option<T>

an empty Option

See

• Option.Some
• Option.wrap

option.ts:589

▸ Ok<T, E>(value): Result<T, E>

Construct a Result containing a success value.

Result<T, E>

a Result containing value

See

• Result.Err
• Result.wrap
• Result.wrapAsync

result.ts:580

▸ Some<T>(value): Option<T>

Construct an Option containing a value.

Option<T>

an Option containing value

See

• Option.None
• Option.wrap

option.ts:578