JSPM

option-t

0.17.0-beta.2
  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 81014
  • Score
    100M100P100Q186107F
  • License MIT

Option type implementation whose APIs are inspired by Rust's `Option<T>`.

Package Exports

  • option-t

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (option-t) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

option-t

npm version Build Status

  • This library represents Option type in ECMAScript.
  • APIs are inspired by Rust Language's Option<T>.

Installation

npm install --save option-t

Usage

var OptionT = require('option-t');

// `Some<T>`
var some = new OptionT.Some(1);
console.log(some.isSome); // true
console.log(some.unwrap()); // 1

// `None`
var none = new OptionT.None();
console.log(none.isSome); // false
console.log(none.unwrap()); // this will throw `Error`.

JSON Representation

Some<T>

new Some(1) will be:

{
    "is_some": true,
    "value": 1
}

None

new None() will be:

{
    "is_some": false
}

API

Cast Option<T> as Promise<T>.

This library provides Option<T>.asPromise() to cast Option<T> as Promise<T>. It returns ES6 Promise. Before call this method, you must import some ES6 Promise polyfill because this method requires Promise.resolve() and Promise.reject().

If you'd like to cast Option<T> as other promise style object, you can write a custom cast function. See #51 which describes a proof of concept.

Semantics

This library represents Option type in ECMAScript. So this object will be the one of following states:

  • Some<T>
    • option instanceof OptionT.Some
    • option.isSome === true.
  • None
    • option instanceof OptionT.None
    • option.isSome === false.

Option<T>

This type is a interface to represent Option<T>. Some<T> and None must implement this Option<T> interface.

This is just interface. This is not exported to an environment which has no interface feature as a part of its type system like TypeScript.

If you'd like to check whether the object option is Option<T> or not in such an environment, you can use option instanceof OptionT.OptionBase to check it.

But this way is not a tier-1 approach. We recommend to use a interface and type system strongly.

We export OptionT.OptionBase object to the type definition for TypeScript, but this is only for the compatibility to cooperate with some libralies which are use instanceof checking to work together with others in the pure JavaScript world. Our basic stance is that you should not use OptionT.OptionBase and need not it in almost case in TypeScript or other static typed languages.

Some<T>

This type represents that there are some values T. If this value wraps null, it just means that there is a null value.

None (None<T>)

This type represents that there is no value explicitly. It is just None !== null.

License

MIT License