百科.dev
全部条目在线工具AI 编程趋势榜开源项目技术资讯提交条目
登录
< 返回工具列表
T

TsMonad

> 编程语言
开源

专为 TypeScript 设计的小型 Monad 库

395 stars0 点赞1 次浏览
访问官网GitHub

工具介绍

专为 TypeScript 设计的小型 Monad 库

TsMonad

  • a simple and pragmatic monad library
  • designed for TypeScript
  • with the aim of limiting errors due to unhandled nulls

Status

Sorry folks, I don't have time to actively maintain this project. Glad it has been of help to some people and thanks everyone for your contributions!

I'm not seeking maintainer to take over - of course feel free to fork if you'd like to continue developing TsMonad.

Description

This library provides implementations of the most useful monads outside of Haskell (subjectively, this is Maybe and Either). It also provides a strongly-typed emulation of pattern matching to help enforce program correctness.

I won't presume to attempt a monad tutorial here. There are several online - I recommend Douglas Crockford's Monads & Gonads talk.

License

MIT

Usage

This library will work with vanilla ES3 JavaScript with node or in the browser. However, it is far better with TypeScript.

Node:

var TsMonad = require('tsmonad');

Browser:

TypeScript definitions:

/// 

Examples (in TypeScript)

You can see the unit tests for the examples below online here and view the source in test/examples.ts.

Pattern matching emulation

typescript
var turns_out_to_be_100 = Maybe.just(10)
    .caseOf({
        just: n => n * n,
        nothing: () => -1
    });

var turns_out_to_be_a_piano = Maybe.nothing()
    .caseOf({
        just: n => n * n,
        nothing: () => -1 // joke, it's negative one not a piano
    });

var turns_out_to_throw_a_compiler_error = Maybe.just(321)
    .caseOf({
        just: n => 999,
        // tsc will tell you that this "does not implement 'nothing'"
        // helping to enforce correct handling of all possible paths
    });

General Maybe usage

The Maybe monad can simplify processing of values that may not exist:

typescript
var canRideForFree = user.getAge()  // user might not have provided age, this is a Maybe
    .bind(age => getBusPass(age))   // not all ages have a bus pass, this is a Maybe
    .caseOf({
        just: busPass => busPass.isValidForRoute('Weston'),
        nothing: () => false
    });

Without Maybe, this would be something like:

typescript
var canRideForFree,
    age = user.getAge(); // might be null or undefined

if (age) {
    var busPass = getBusPass(age); // might be null or undefined
    if (busPass) {
        canRideForFree = busPass.isValidForRoute('Weston');
    }
}
canRideForFree = false;

Please excuse the messy var scoping and implicit any types in the above. Again, the neat thing about the caseOf method is that it forces you to consider the failure case - it's not always obvious if you're missing a branch of your if-else statement, until it blows up at runtime.

There are some convenience methods in Maybe:

typescript
user.getLikesCookies().defaulting(false); // Maybe
user.getLikesCookies().valueOr(false); // false
user.getLikesCookies().valueOrCompute(() => expensiveCalculation());
user.getLikesCookies().valueOrThrow(new Error());

// Maybe.just({ three: 3, hi: 'hi'})
Maybe.sequence({ three: Maybe.just(3), hi: Maybe.just('hi') });

// Maybe.nothing
Maybe.sequence({ three: Maybe.just(3), hi: Maybe.nothing() });

General Either usage

typescript
var canRideForFree = user.getAge()  // either 42 or 'Information withheld' - type of Either
    .bind(age => getBusPass(age))   // either busPass or 'Too young for a bus pass' - type of Either
    .caseOf({
        right: busPass => busPass.isValidForRoute('Weston'),
        left: errorMessage => { console.log(errorMessage); return false; }
    });

General Writer usage

Somewhat contrived example of recording arithmetic operations:

typescript
var is_true = Writer.writer(['Started with 0'], 0)
    .bind(x => Writer.writer(['+ 8'], x + 8))
    .bind(x => Writer.writer(['- 6', '* 8'], 8 * (x - 6)))
    .caseOf({
        writer: (s, v) => v === 16 && s.join(', ') === 'Started with 0, + 8, - 6, * 8'
    }));

The lift method (fmap)

The lift method takes a lambda, applies it to the wrapped value and calls the unit function of the monad on the result (e.g. for Maybe it calls just). Useful when you want to bind to a function that doesn't return a monad.

typescript
var turns_out_to_be_true = Maybe.just(123)
    .lift(n => n * 2)
    .caseOf({
        just: n => n === 246,
        nothing: () => false
    });

Note that for Maybe, if the lifted function returns null or undefined then it returns Nothing rather than wrapping a null in a Just, which is perverse.

FAQ and apologies

Why only Maybe, Either and Writer (so far)?

These monads are the most obviously useful in JavaScript's world of unrestricted mutable state and side effects. I'm currently evaluating which other common monads offer enough benefit to be worth implementing in TypeScript.

Where's monad transformers?

Sorry. One day. But for the moment it's not practicable to do this without support for higher-kinded types.

Is it Fantasy Land conformant?

Yes - there are aliases for Fantasy Land interfaces of Functor and Monad.

Issues· 5 开放

查看全部 Issues在 GitHub 打开

暂无开放 Issues,或尚未同步最近议题。

> 标签

TypeScriptfantasy-landjavascriptmonadmonad-library

暂无评论,来聊聊你的看法吧

> 工具信息

发布日期2026年8月1日
最后更新2026年9月17日
分类编程语言
定价开源

> 相关工具

T
TypeScript
JavaScript 的超集,为前端与全栈提供静态类型
P
Python
通用编程语言,广泛用于 Web、数据与 AI
G
Go
Google 推出的简洁高效系统语言