@cprussin/option-result
Version:
Yet another Typescript clone of the rust `Option` & `Result` enums.
72 lines (71 loc) • 2.76 kB
TypeScript
/**
* @packageDocumentation
*
* 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
* ```ts
* 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:
*
* 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.
*
* ## 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:
*
* 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.
*/
export * from "./result.js";
export * from "./option.js";