fp-ts-wonka
Version:
[fp-ts](https://github.com/gcanti/fp-ts) bindings for [wonka](https://wonka.kitten.sh/)
404 lines • 9.39 kB
JavaScript
import { apS as apS_ } from 'fp-ts/Apply';
import * as E from 'fp-ts/Either';
import { flow, identity, pipe } from 'fp-ts/function';
import { bindTo as bindTo_, flap as flap_ } from 'fp-ts/Functor';
import { bind as bind_, chainFirst as chainFirst_ } from 'fp-ts/Chain';
import * as O from 'fp-ts/Option';
import * as Wonka from 'wonka';
import { defer } from './sources';
// -------------------------------------------------------------------------------------
// natural transformations
// -------------------------------------------------------------------------------------
/**
* @since 0.1.0
* @category Natural transformations
*/
export var fromOption = function (o) {
return O.isNone(o) ? Wonka.empty : Wonka.fromValue(o.value);
};
/**
* @since 0.1.0
* @category Natural transformations
*/
export var fromIO = function (ma) {
return defer(function () { return Wonka.fromValue(ma()); });
};
/**
* @since 0.1.0
* @category Natural transformations
*/
export var fromTask = function (ma) {
return defer(function () { return Wonka.fromPromise(ma()); });
};
// -------------------------------------------------------------------------------------
// non-pipeables
// -------------------------------------------------------------------------------------
var _map = function (fa, f) { return pipe(fa, map(f)); };
var _ap = function (fab, fa) { return pipe(fab, ap(fa)); };
/* istanbul ignore next */
var _chain = function (fa, f) { return pipe(fa, chain(f)); };
/* istanbul ignore next */
var _alt = function (me, that) { return pipe(me, alt(that)); };
/* istanbul ignore next */
var _filter = function (fa, p) { return pipe(fa, filter(p)); };
/* istanbul ignore next */
var _filterMap = function (fa, f) { return pipe(fa, filterMap(f)); };
/* istanbul ignore next */
var _partition = function (fa, p) { return pipe(fa, partition(p)); };
/* istanbul ignore next */
var _partitionMap = function (fa, f) {
return pipe(fa, partitionMap(f));
};
// -------------------------------------------------------------------------------------
// type class members
// -------------------------------------------------------------------------------------
/**
* `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>)
* => F<B>` whose argument and return types use the type constructor `F` to
* represent some computational context.
*
* @since 0.1.0
* @category Functor
*/
export var map = function (f) { return function (fa) {
return pipe(fa, Wonka.map(f));
}; };
/**
* Apply a function to an argument under a type constructor.
*
* @since 0.1.0
* @category Apply
*/
export var ap = function (fa) { return function (fab) {
return pipe(Wonka.combine(fab, fa), Wonka.map(function (_a) {
var f = _a[0], a = _a[1];
return f(a);
}));
}; };
/**
* Apply a function to an argument under a type constructor.
*
* @since 0.1.0
* @category Apply
*/
export var apW = ap;
/**
* Combine two effectful actions, keeping only the result of the first.
*
* Derivable from `Apply`.
*
* @since 0.1.0
* @category Combinators
*/
export var apFirst = function (fb) {
return flow(map(function (a) { return function () { return a; }; }), ap(fb));
};
/**
* Combine two effectful actions, keeping only the result of the second.
*
* Derivable from `Apply`.
*
* @since 0.1.0
* @category Combinators
*/
export var apSecond = function (fb) {
return flow(map(function () { return function (b) { return b; }; }), ap(fb));
};
/**
* @since 0.1.0
* @category Pointed
*/
export var of = Wonka.fromValue;
/**
* Composes computations in sequence, using the return value of one computation
* to determine the next computation.
*
* @since 0.1.0
* @category Monad
*/
export var chain = function (f) { return function (ma) {
return pipe(ma, Wonka.mergeMap(f));
}; };
/**
* Derivable from `Monad`.
*
* @since 0.1.0
* @category Combinators
*/
export var flatten =
/*#__PURE__*/
chain(identity);
/**
* Identifies an associative operation on a type constructor. It is similar to
* `Semigroup`, except that it applies to types of kind `* -> *`.
*
* @since 0.1.0
* @category Alt
*/
export var alt = function (that) { return function (fa) {
return Wonka.merge([fa, that()]);
}; };
/**
* @since 0.1.0
* @category Filterable
*/
export var filterMap = function (f) {
return function (fa) {
return pipe(fa, Wonka.mergeMap(function (a) {
return pipe(f(a), O.fold(function () { return Wonka.empty; }, of));
}));
};
};
/**
* @since 0.1.0
* @category Compactable
*/
export var compact =
/*#__PURE__*/
filterMap(identity);
/**
* @since 0.1.0
* @category Filterable
*/
export var partitionMap = function (f) { return function (fa) { return ({
left: pipe(fa, filterMap(function (a) { return O.fromEither(E.swap(f(a))); })),
right: pipe(fa, filterMap(function (a) { return O.fromEither(f(a)); })),
}); }; };
/**
* @since 0.1.0
* @category Compactable
*/
export var separate =
/*#__PURE__*/
partitionMap(identity);
/**
* @since 0.1.0
* @category Filterable
*/
export var filter = function (p) {
return function (fa) {
return pipe(fa, filterMap(O.fromPredicate(p)));
};
};
/**
* @since 0.1.0
* @category Filterable
*/
export var partition = function (p) {
return function (fa) {
return pipe(fa, partitionMap(E.fromPredicate(p, identity)));
};
};
/**
* @since 0.1.0
* @category Alternative
*/
export var zero = function () { return Wonka.empty; };
// -------------------------------------------------------------------------------------
// instances
// -------------------------------------------------------------------------------------
/**
* @since 0.1.0
* @category Instances
*/
export var URI = 'wonka/Source';
/**
* @since 0.1.0
* @category Instances
*/
export var getMonoid = function () { return ({
concat: function (x, y) { return Wonka.merge([x, y]); },
empty: Wonka.empty,
}); };
/**
* @since 0.1.0
* @category Instances
*/
export var Functor = {
URI: URI,
map: _map,
};
/**
* @since 0.1.0
* @category Instances
*/
export var Pointed = {
URI: URI,
of: of,
};
/**
* Derivable from `Functor`.
*
* @since 0.1.0
* @category Combinators
*/
export var flap =
/*#__PURE__*/
flap_(Functor);
/**
* @since 0.1.0
* @category Instances
*/
export var Apply = {
URI: URI,
map: _map,
ap: _ap,
};
/**
* @since 0.1.0
* @category Instances
*/
export var Applicative = {
URI: URI,
map: _map,
ap: _ap,
of: of,
};
/**
* @since 0.1.0
* @category Instances
*/
export var Chain = {
URI: URI,
map: _map,
ap: _ap,
chain: _chain,
};
/**
* Composes computations in sequence, using the return value of one computation
* to determine the next computation and keeping only the result of the first.
*
* Derivable from `Monad`.
*
* @since 0.1.0
* @category Combinators
*/
export var chainFirst = chainFirst_(Chain);
/**
* @since 0.1.0
* @category Instances
*/
export var Monad = {
URI: URI,
map: _map,
ap: _ap,
of: of,
chain: _chain,
};
/**
* @since 0.1.0
* @category Instances
*/
export var Alt = {
URI: URI,
map: _map,
alt: _alt,
};
/**
* @since 0.1.0
* @category Instances
*/
export var Alternative = {
URI: URI,
map: _map,
ap: _ap,
of: of,
alt: _alt,
zero: zero,
};
/**
* @since 0.1.0
* @category Instances
*/
export var Compactable = {
URI: URI,
compact: compact,
separate: separate,
};
/**
* @since 0.1.0
* @category Instances
*/
export var Filterable = {
URI: URI,
compact: compact,
separate: separate,
map: _map,
filter: _filter,
filterMap: _filterMap,
partition: _partition,
partitionMap: _partitionMap,
};
/**
* @since 0.1.0
* @category Instances
*/
export var MonadIO = {
URI: URI,
map: _map,
ap: _ap,
of: of,
chain: _chain,
fromIO: fromIO,
};
/**
* @since 0.1.0
* @category Instances
*/
export var MonadTask = {
URI: URI,
map: _map,
ap: _ap,
of: of,
chain: _chain,
fromIO: fromIO,
fromTask: fromTask,
};
/**
* @since 0.1.0
* @category Instances
*/
export var MonadSource = {
URI: URI,
map: _map,
ap: _ap,
of: of,
chain: _chain,
fromIO: fromIO,
fromTask: fromTask,
fromSource: identity,
};
// -------------------------------------------------------------------------------------
// do notation
// -------------------------------------------------------------------------------------
/** @since 0.1.0 */
export var Do =
/*#__PURE__*/
of({});
/** @since 0.1.0 */
export var bindTo =
/*#__PURE__*/
bindTo_(Functor);
/** @since 0.1.0 */
export var bind =
/*#__PURE__*/
bind_(Chain);
// -------------------------------------------------------------------------------------
// pipeable sequence S
// -------------------------------------------------------------------------------------
/** @since 0.1.0 */
export var apS =
/*#__PURE__*/
apS_(Apply);
/** @since 0.1.0 */
export var apSW = apS;
// -------------------------------------------------------------------------------------
// utils
// -------------------------------------------------------------------------------------
/** @since 0.1.0 */
export var toTask = function (s) {
return function () {
return Wonka.toPromise(s);
};
};
//# sourceMappingURL=Source.js.map