npmpackage.info

Gathering detailed insights and metrics for option-monad-ts

Other packages similar to option-monad-ts

ts-results

3.3.0

A typescript implementation of Rust's Result and Option objects.

ts-results-es

5.0.1

A TypeScript implementation of Rust's Result and Option objects.

@mobily/ts-belt

3.13.1

🔧 Fast, modern, and practical utility library for FP in TypeScript.

ts-option-monad

1.1.0

``` npm install ts-option-monad ```

Gathering detailed insights and metrics for option-monad-ts

option-monad-ts - 0.1.4 | npmpackage.info

option-monad-ts

Option Monad for TypeScript

0.1.4

MIT

TypeScript

400.00 B

3,842 2.6

Installations

npm install option-monad-ts

Developer Guide

BETA

Typescript

Yes

Module System

CommonJS

Node Version

12.18.3

NPM Version

6.14.6 Score

70.3

Supply Chain

85.1

Quality

75.6

Maintenance

100

Vulnerability

100

License

Pull Requests

Open

0

Total

1

Closed

1

Issues

Open

0

Total

0

Closed

0

Releases

Unable to fetch releases

Languages

TypeScript

TypeScript (100%)

Developer

sdedovic

Download Statistics

Total Downloads

3,842

Last Day

Last Week

Last Month

Last Year

522

GitHub Statistics

MIT License

1 Stars

14 Commits

2 Watchers

2 Branches

2 Contributors

Updated on Apr 16, 2021

Bundle Size

782.00 B

Minified

400.00 B

Minified + Gzipped

Bundlephobia

Maintainers

View All 2 Contributors

Package Meta Information

Latest Version

0.1.4

Package Id

option-monad-ts@0.1.4

Unpacked Size

12.02 kB

Size

3.82 kB

File Count

NPM Version

6.14.6

Node Version

12.18.3

Total Downloads

Cumulative downloads

Total Downloads

3,842

Last Day

100%

Compared to previous day

Last Week

2,800%

Compared to previous week

Last Month

272.7%

Compared to previous month

Last Year

9.4%

522

Compared to previous year

Weekly Downloads

Monthly Downloads

Yearly Downloads

Dev Dependencies

@types/jest @types/node jest ts-jest ts-loader ts-node typescript

Option monad for Typescript

Yet another port of the Scala Option type to TypeScript.

npm (tag)

1npm i --save option-monad-ts

Usage

Basic Example

1import { Option, Some, None } from 'option-monad-ts';
2
3// Create Some 
4let n = new Some(3);
5let m = Some.of('four');
6
7// Create Option
8let c = Option.of(3);
9let d = Option.of(null);
10
11// Validate and use
12n.get();                    // 3
13m.get();                    // 'four'
14
15c.isDefined();              // true
16d.isDefined();              // false
17
18Some.of(4)
19    .map(_ => _.toString())
20    .forEach(_ => console.log(_))

Documentation

`Option<T>`

static `of<T>(x: T): Option<T>`

An Option factory which creates Some.of(x) if the argument is not null, and None if it is null.

`filter(p: (i: T) => boolean): Option<T>`

Returns this Option if it is nonempty and applying the predicate p to this Option's value returns true. Otherwise, return None.

`flatMap<R>(f: (i: T) => Option<R>): Option<R>`

Returns the result of applying f to this Option's value if this Option is nonempty. Returns None if this Option is empty. Slightly different from map in that f is expected to return an Option (which could be None).

`forEach<U>(f: (i: T) => U): void`

Apply the given procedure f to the option's value, if it is nonempty. Otherwise, do nothing.

`get(): T`

Returns the option's value. The option must be nonEmpty.

`getOrElse(defaultValue: T): T`

Returns the option's value if the option is nonempty, otherwise return defaultValue.

`isDefined(): boolean`

Returns true if the option is an instance of Some, false otherwise.

`isEmpty(): boolean`

Returns true if the option is None, false otherwise.

`map<R>(f: (i: T) => R): Option<R>`

Returns a Some containing the result of applying f to this Option's value if this Option is nonempty. Otherwise, return None.

Why another library?

I thought it would be a good exercise
I didn't like the API/usage patterns of some existing libraries
I wanted something as close to the Scala lib as possible, so I ported it trying to keep to its spirit

No vulnerabilities found.

10

Dangerous-Workflow

Determines if the project's GitHub Action workflows avoid dangerous patterns.

10

Binary-Artifacts

Determines if the project has generated executable (binary) artifacts in the source repository.

10

License

Determines if the project has defined a license.

2

Pinned-Dependencies

Determines if the project has declared and pinned the dependencies of its build process.

0

Maintained

Determines if the project is "actively maintained".

0

Code-Review

Determines if the project requires human code review before pull requests (aka merge requests) are merged.

0

SAST

Determines if the project uses static code analysis.

0

Token-Permissions

Determines if the project's workflows follow the principle of least privilege.

0

CII-Best-Practices

Determines if the project has an OpenSSF (formerly CII) Best Practices Badge.

0

Fuzzing

Determines if the project uses fuzzing.

0

Security-Policy

Determines if the project has published a security policy.

0

Branch-Protection

Determines if the default and release branches are protected with GitHub's branch protection settings.

0

Vulnerabilities

Determines if the project has open, known unfixed vulnerabilities.

Score

2.6

/10

Last Scanned on 2025-06-09

The Open Source Security Foundation is a cross-industry collaboration to improve the security of open source software (OSS). The Scorecard provides security health metrics for open source projects.

Learn More

Other packages similar to option-monad-ts

Other packages similar to option-monad-ts

option-monad-ts

Installations

Developer Guide

Yes

CommonJS

12.18.3

6.14.6

Score

Pull Requests

0

1

1

Issues

0

0

0

Releases

Unable to fetch releases

Languages

Developer

sdedovic

Download Statistics

GitHub Statistics

Bundle Size

782.00 B

400.00 B

Maintainers

Package Meta Information

Total Downloads

3,842

Weekly Downloads

Monthly Downloads

Yearly Downloads

Dev Dependencies

Option monad for Typescript

Usage

Basic Example

Documentation

Option<T>

static of<T>(x: T): Option<T>

filter(p: (i: T) => boolean): Option<T>

flatMap<R>(f: (i: T) => Option<R>): Option<R>

forEach<U>(f: (i: T) => U): void

get(): T

getOrElse(defaultValue: T): T

isDefined(): boolean

isEmpty(): boolean

map<R>(f: (i: T) => R): Option<R>

Why another library?

10

10

10

2

0

0

0

0

0

0

0

0

0

2.6

/10

`Option<T>`

static `of<T>(x: T): Option<T>`

`filter(p: (i: T) => boolean): Option<T>`

`flatMap<R>(f: (i: T) => Option<R>): Option<R>`

`forEach<U>(f: (i: T) => U): void`

`get(): T`

`getOrElse(defaultValue: T): T`

`isDefined(): boolean`

`isEmpty(): boolean`

`map<R>(f: (i: T) => R): Option<R>`