R | /mod.ts | ahh@v0.9.1

class R

import { R } from "https://deno.land/x/ahh@v0.9.1/mod.ts";

Functionality for Result.

Static Methods

contains<T, E extends Error>(r: Result<T, E>, v: T): boolean

Returns whether the contained Ok value strictly equals v.

Examples

import { R } from "./mod.ts";

console.log(R.contains(1, 1)); // true
console.log(R.contains(1, 2)); // false
console.log(R.contains(Error("whoops"), 1)); // false

containsErr<T, E extends Error>(r: Result<T, E>, v: E): boolean

Returns whether the contained Err value strictly equals v.

This checks all fields except for stack which is usually the desired behaviour.

Examples

import { R } from "./mod.ts";

console.log(R.containsErr(Error("whoops"), Error("whoops"))); // true
console.log(R.containsErr(Error("whoops"), Error("spoohw"))); // false
console.log(R.containsErr(1, Error("whoops"))); // false

err<T, E extends Error>(r: Result<T, E>): Option<E>

Converts an Err into an Option.

Examples

import { R } from "./mod.ts";

console.log(R.err(Error("whoops"))); // Error("whoops")
console.log(R.err(1)); // undefined

expect<T, E extends Error>(r: Result<T, E>, message: string): r extends Ok<T> ? T : never

Returns the contained Ok value.

Throws if the Result is an Err with the provided message.

Examples

import { R } from "./mod.ts";

console.log(R.expect(1, "returns")); // 1
R.expect(Error("whoops"), "throws"); // throws

expectErr<T, E extends Error>(r: Result<T, E>, message: string): r extends Err<E> ? E : never

Returns the contained Err value.

Throws if the Result is an Ok with the provided message.

Examples

import { R } from "./mod.ts";

console.log(R.expectErr(Error("whoops"), "returns")); // Error("whoops")
R.expectErr(1, "throws"); // throws

fn<T, E extends Error>(f: () => T): Result<T, E>

Creates an Ok from the return value of f, otherwise an Err if it throws.

Examples

import { R } from "./mod.ts";

console.log(R.fn(() => 1)); // 1
console.log(R.fn(() => { throw Error(); })); // Error()

isErr<T, E extends Error>(r: Result<T, E>): r is Err<E>

Returns whether a Result is an Err.

Examples

import { R } from "./mod.ts";

console.log(R.isErr(1)); // false
console.log(R.isErr(Error())); // true

isOk<T, E extends Error>(r: Result<T, E>): r is Ok<T>

Returns whether a Result is an Ok.

Examples

import { R } from "./mod.ts";

console.log(R.isOk(1)); // true
console.log(R.isOk(Error())); // false

map<T, E extends Error, U>(r: Result<T, E>, f: (_: T) => U): Result<U, E>

Maps the contained Ok value with f, otherwise Err.

Examples

import { R } from "./mod.ts";

console.log(R.map(1, (i) => i + 1)); // 2
console.log(R.map<number, Error, number>(Error("whoops"), (i) => i + 1)); // Error("whoops")

mapErr<T, E extends Error, F extends Error>(r: Result<T, E>, f: (_: E) => F): Result<T, F>

Maps the contained Err value with f, otherwise Ok.

Examples

import { R } from "./mod.ts";

console.log(R.mapErr(1, (i) => Error(i.message + "bar"))); // 1
console.log(R.mapErr(Error("foo"), (i) => Error(i.message + "bar"))); // Error("foobar")

ok<T, E extends Error>(r: Result<T, E>): Option<T>

Converts an Ok into an Option.

Examples

import { R } from "./mod.ts";

console.log(R.ok(1)); // 1
console.log(R.ok(Error("whoops"))); // undefined

unwrap<T, E extends Error>(r: Result<T, E>): r extends Ok<T> ? T : never

Returns the contained Ok value.

Throws if the Result is an Err.

Examples

import { R } from "./mod.ts";

console.log(R.unwrap(1)); // 1
R.unwrap(Error("whoops")); // throws

unwrapErr<T, E extends Error>(r: Result<T, E>): r extends Err<E> ? E : never

Returns the contained Err value.

Throws if the Result is an Ok.

Examples

import { R } from "./mod.ts";

console.log(R.unwrapErr(Error("whoops"))); // Error("whoops")
R.unwrapErr(1); // throws

unwrapOr<T, E extends Error>(r: Result<T, E>, v: T): T

Returns the contained Ok value or the provided default.

Examples

import { R } from "./mod.ts";

console.log(R.unwrapOr<number, Error>(1, 5)); // 1
console.log(R.unwrapOr(Error("whoops"), 5)); // 5