NeverThrow

類似

method chainでResult型を扱える

fp-tsよりも範囲狭いし、簡単そうで良さそう

fp-tsよりもtypescriptからの逸脱さが小さい気がする

monadシラン人でも直感的に扱えそう

fp-tsはpipeだったり、doだったりある

同じようなコードを書いて比較してみるか

code:ts

import { Result } from "neverthrow";

type ParseError = { message: string };

const toParseError = (): ParseError => ({ message: "Parse Error" });

const safeJsonParse = Result.fromThrowable(JSON.parse, toParseError);

const res = safeJsonParse("{");

使用例

code:ts

import { Result, ok, err } from "neverthrow";

function itsUnder100(n: number): Result<number, Error> {

return n <= 100 ? ok(n) : err(new Error("Number is over 100"));

}

function itsEven(n: number): Result<number, Error> {

return n % 2 === 0 ? ok(n) : err(new Error("Number is odd"));

}

function itsPositive(n: number): Result<number, Error> {

return n >= 0 ? ok(n) : err(new Error("Number is negative"));

}

const result = ok(96)

.andThen(itsUnder100)

.andThen(itsEven)

.andThen(itsPositive);

result.match(

(n) => console.log(n),

(e) => console.log(e.message)

);

docsよみ

Recommended: Use eslint-plugin-neverthrow

Top-Level API

API Documentation

Synchronous API (Result)

ok, err

Result.isOk (method), Result.isErr (method)

code:hs

map :: (a -> b) -> Either e a -> Either e b

Okならその値を返し、Errなら引数のdefault値を返す

andThen

Result.asyncAndThen (method)

引数の関数が、error handlerになる

code:hs

orElse :: e -> Either t a -> Either t a

Result.match (method)

Result.asyncMap (method)

Result.fromThrowable (static class method)

Result.combine (static class method)

function combine<T, E>(resultList: Result<T, E>[]): Result<T[], E>

Result.combineWithAllErrors (static class method)

Asynchronous API (ResultAsync)

okAsync

errAsync

ResultAsync.fromPromise (static class method)

ResultAsync.fromSafePromise (static class method)

ResultAsync.map (method)

ResultAsync.mapErr (method)

ResultAsync.unwrapOr (method)

ResultAsync.andThen (method)

ResultAsync.orElse (method)

ResultAsync.match (method)

Utilities

fromThrowable

fromPromise

fromSafePromise

Testing

A note on the Package Name