ruins-ts
Ruins-ts is a library that converts TypeScript fp-ts types into primitive types familiar to most JavaScript programmers. Using ruins-ts is generally speaking a bad idea since the corresponding fp-ts types give much stronger guarantees about the values than their primitive JavaScript counterparts. However, if you wish you had a sledge hammer for breaking your application into smithereens, ruins-ts may be what you are looking for.
Ruins-ts was originally created as a convenience wrapper for dealing with io-ts codec return values. However, the io-ts-validator has long ago surpassed ruins-ts for validation use. The ruins-ts is maintained by the time being for adhoc use, where writing a specific convenience library may not be feasible. If you have managed to read this far you may start using ruins-ts by importing it as follows.
import * as ruins from 'ruins-ts';
ruins.fromOption; // terminates Option, returns nullable
ruins.fromEither; // terminates Either, throws on error
ruins.fromThese; // terminates These, logs warnings to console
ruins.fromIO; // terminates IO, returns the result
ruins.fromIOEither; // terminates IOEither, throws on error
ruins.fromTask; // terminates Task, returns a promise
ruins.fromTaskOption; // terminates TaskOption, resolves to nullable
ruins.fromTaskEither; // terminates TaskEither, rejects with error
ruins.fromTaskThese; // terminates TaskThese, logs warnings to consolefromOption (function)
Returns the raw value in case of Some and null in case of None.
Makes it impossible to distinguish between a null value and no value.
Signature
export function fromOption<R>(anOption: Option<R>): R | null { ... }Example
import { Option } from 'fp-ts/lib/Option';
import * as Option_ from 'fp-ts/lib/Option';
const someNumber: Option<number> = Option_.some(123);
const noNumber: Option<number> = Option_.none;
ruins.fromOption(someNumber); // => 123
ruins.fromOption(noNumber); // => null
type Foo = string | null;
const stringValue: Option<Foo> = Option_.some('foo');
const nullValue: Option<Foo> = Option_.some(null);
const noValue: Option<Foo> = Option_.none;
ruins.fromOption(stringValue); // => 'foo'
ruins.fromOption(nullValue); // => null
ruins.fromOption(noValue); // => null
nullValue === noValue; // => false
ruins.fromOption(nullValue) === ruins.fromOption(noValue); // => truefromEither (function)
Asserts Right and returns the result.
Throws a runtime Error on Left.
Signature
export function fromEither<R>(anEither: Either<unknown, R>): R { ... }Example
import { Either } from 'fp-ts/lib/Either';
import * as Either_ from 'fp-ts/lib/Either';
const failureE: Either<string, number> = Either_.left('error');
const successE: Either<string, number> = Either_.right(123);
ruins.fromEither(failureE); // => never (throws an exception)
ruins.fromEither(successE); // => 123fromThese (function)
Asserts Right and returns the result.
Logs warnings to console on Both.
Throws a runtime Error on Left.
Signature
export function fromThese<R>(aThese: These<unknown, R>): R { ... }Example
import { These } from 'fp-ts/lib/These';
import * as These_ from 'fp-ts/lib/These';
const failureT: These<string, number> = These_.left('error');
const successT: These<string, number> = These_.right(123);
const neutralT: These<string, number> = These_.both('warning', 456);
ruins.fromThese(failureT); // => never (throws an exception)
ruins.fromThese(successT); // => 123
ruins.fromThese(neutralT); // => 456 (logs warning)fromIO (function)
Executes syncronous side-effects of an IO and returns the result.
Breaks referential transparency.
Signature
export function fromIO<R>(anIO: IO<R>): R { ... }Example
import { IO } from 'fp-ts/lib/IO';
const syncComputation: IO<number> = () => {
console.log('effect');
return 123;
};
ruins.fromIO(syncComputation); // => 123 (prints "effect")fromIOEither (function)
Executes contained syncronous side-effects, asserts Right and returns the result.
Breaks referential transparency. Throws a runtime Error on Left.
Signature
export function fromIOEither<E, R>(anIOEither: IOEither<E, R>): R { ... }Example
import { IOEither } from 'fp-ts/lib/IOEither';
const failureIOE: IOEither<string, number> = () => {
console.log('effect');
return Either_.left('error');
};
const successIOE: IOEither<string, number> = () => {
console.log('effect');
return Either_.right(123);
};
ruins.fromIOEither(failureIOE); // => never (prints "effect", throws an exception)
ruins.fromIOEither(successIOE); // => 123 (prints "effect")fromTask (function)
Executes asyncronous side-effects of a Task and returns the result wrapped in a promise.
Breaks referential transparency.
Signature
export function fromTask<R>(aTask: Task<R>): Promise<R> { ... }Example
import { Task } from 'fp-ts/lib/Task';
const asyncComputation: Task<number> = () =>
new Promise((resolve) => {
console.log('effect');
resolve(123);
});
ruins.fromTask(asyncComputation); // => Promise (prints "effect", resolves to 123)fromTaskOption (function)
Executes contained asyncronous side-effects and returns nullable result wrapped in a promise.
Breaks referential transparency.
Signature
export function fromTaskOption<R>(aTaskOption: TaskOption<R>): Promise<R|null> { ... }Example
import { TaskOption } from 'fp-ts/lib/TaskOption';
const failureTO: TaskOption<number> = () =>
new Promise((_resolve, reject) => {
console.log('effect');
reject(Option_.none);
});
const successTO: TaskOption<number> = () =>
new Promise((resolve, _reject) => {
console.log('effect');
resolve(Option_.some(123));
});
ruins.fromTaskOption(failureTO); // => Promise (prints "effect", resolves to null)
ruins.fromTaskOption(successTO); // => Promise (prints "effect", resolves to 123)fromTaskEither (function)
Executes contained asyncronous side-effects and returns the result wrapped in a promise.
Breaks referential transparency.
Signature
export function fromTaskEither<E, R>(aTaskEither: TaskEither<E, R>): Promise<R> { ... }Example
import { TaskEither } from 'fp-ts/lib/TaskEither';
const failureTE: TaskEither<string, number> = () =>
new Promise((_resolve, reject) => {
console.log('effect');
reject(Either_.left('error'));
});
const successTE: TaskEither<string, number> = () =>
new Promise((resolve, _reject) => {
console.log('effect');
resolve(Either_.right(123));
});
ruins.fromTaskEither(failureTE); // => Promise (prints "effect", rejects)
ruins.fromTaskEither(successTE); // => Promise (prints "effect", resolves to 123)fromTaskThese (function)
Executes contained asyncronous side-effects and returns the result wrapped in a promise.
Breaks referential transparency.
Signature
export function fromTaskThese<E, R>(aTaskThese: TaskThese<E, R>): Promise<R> { ... }Example
import { TaskThese } from 'fp-ts/lib/TaskThese';
const failureTT: TaskThese<string, number> = () =>
new Promise((_resolve, reject) => {
console.log('effect');
reject(These_.left('error'));
});
const successTT: TaskThese<string, number> = () =>
new Promise((resolve, _reject) => {
console.log('effect');
resolve(These_.right(123));
});
const neutralTT: TaskThese<string, number> = () =>
new Promise((resolve, _reject) => {
console.log('effect');
resolve(These_.both('warning', 456));
});
ruins.fromTaskThese(failureTT); // => Promise (prints "effect", rejects)
ruins.fromTaskThese(successTT); // => Promise (prints "effect", resolves to 123)
ruins.fromTaskThese(neutralTT); // => Promise (prints "effect", logs warning, resolves to 456)
