fortepiano 0.1.0

package/lib/Mock.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.null = exports.undefined = exports.void = exports.readonlyRecord = exports.readonlyNonEmptyArray = exports.readonlyArray = exports.union = exports.partial = exports.struct = exports.tuple = exports.nullable = exports.unknown = exports.literal = exports.string = exports.number = exports.integer = exports.float = exports.boolean = exports.MonadIO = exports.chainFirstIOK = exports.chainIOK = exports.fromIOK = exports.fromIO = exports.FromIO = exports.Monad = exports.bind = exports.chainFirst = exports.chain = exports.Chain = exports.Applicative = exports.apS = exports.apSecond = exports.apFirst = exports.ap = exports.Apply = exports.Do = exports.of = exports.Pointed = exports.bindTo = exports.flap = exports.map = exports.Functor = exports.URI = void 0;
+const _Apply = __importStar(require("fp-ts/Apply"));
+const C = __importStar(require("fp-ts/Chain"));
+const FIO = __importStar(require("fp-ts/FromIO"));
+const function_1 = require("fp-ts/function");
+const F = __importStar(require("fp-ts/Functor"));
+const IO = __importStar(require("fp-ts/IO"));
+const N = __importStar(require("fp-ts/number"));
+const Op = __importStar(require("fp-ts/Option"));
+const Or = __importStar(require("fp-ts/Ord"));
+const R = __importStar(require("fp-ts/Random"));
+const RA = __importStar(require("fp-ts/ReadonlyArray"));
+const RNEA = __importStar(require("fp-ts/ReadonlyNonEmptyArray"));
+const RR = __importStar(require("fp-ts/ReadonlyRecord"));
+const Se = __importStar(require("fp-ts/Semigroup"));
+const t = __importStar(require("io-ts"));
+const function_2 = require("./function");
+const $GL = __importStar(require("./GeneratorL"));
+const $St = __importStar(require("./struct"));
+const $t = __importStar(require("./Type"));
+exports.URI = 'Mock';
+exports.Functor = {
+    URI: exports.URI,
+    map: (fa, f) => function_1.pipe(fa(), IO.map(f), exports.FromIO.fromIO),
+};
+exports.map = function_2.curry(function_1.flip(exports.Functor.map));
+exports.flap = F.flap(exports.Functor);
+exports.bindTo = F.bindTo(exports.Functor);
+exports.Pointed = {
+    URI: exports.URI,
+    of: (a) => (...as) => function_1.pipe(as, RNEA.fromReadonlyArray, Op.traverse(IO.Applicative)(R.randomElem), IO.map(Op.match(() => a, (_a) => $t.struct.is(a) && $t.struct.is(_a)
+        ? function_1.pipe(_a, $St.filterDeep(function_1.not(t.undefined.is)), (_a) => $St.patch(_a)(a))
+        : _a))),
+};
+exports.of = exports.Pointed.of;
+exports.Do = exports.Pointed.of({});
+exports.Apply = Object.assign(Object.assign({}, exports.Functor), { ap: (fab, fa) => exports.Chain.chain(fab, function_2.curry(exports.Functor.map)(fa)) });
+exports.ap = function_2.curry(function_1.flip(exports.Apply.ap));
+exports.apFirst = _Apply.apFirst(exports.Apply);
+exports.apSecond = _Apply.apSecond(exports.Apply);
+exports.apS = _Apply.apS(exports.Apply);
+exports.Applicative = Object.assign(Object.assign({}, exports.Pointed), exports.Apply);
+exports.Chain = Object.assign(Object.assign({}, exports.Apply), { chain: (fa, f) => exports.Functor.map(exports.Functor.map(fa, f), (fb) => fb()()) });
+exports.chain = function_2.curry(function_1.flip(exports.Chain.chain));
+exports.chainFirst = C.chainFirst(exports.Chain);
+exports.bind = C.bind(exports.Chain);
+exports.Monad = Object.assign(Object.assign({}, exports.Applicative), exports.Chain);
+exports.FromIO = {
+    URI: exports.URI,
+    fromIO: (fa) => (...as) => function_1.pipe(fa, IO.chain((a) => exports.Pointed.of(a)(...as))),
+};
+exports.fromIO = exports.FromIO.fromIO;
+exports.fromIOK = FIO.fromIOK(exports.FromIO);
+exports.chainIOK = FIO.chainIOK(exports.FromIO, exports.Chain);
+exports.chainFirstIOK = FIO.chainFirstIOK(exports.FromIO, exports.Chain);
+exports.MonadIO = Object.assign(Object.assign({}, exports.Monad), exports.FromIO);
+const _void = () => function_1.constVoid;
+exports.void = _void;
+const _undefined = () => function_1.constUndefined;
+exports.undefined = _undefined;
+const _null = () => function_1.constNull;
+exports.null = _null;
+exports.boolean = exports.fromIO(R.randomBool);
+const float = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => function_1.pipe(exports.fromIO(R.randomRange(min, Math.max(min + Number.EPSILON, max)))(...as), IO.map(Or.clamp(N.Ord)(min, Math.max(min + Number.EPSILON, max - Number.EPSILON))));
+exports.float = float;
+const integer = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => function_1.pipe(exports.float(min, max)(...as), IO.map(Math.floor));
+exports.integer = integer;
+const number = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => function_1.pipe(union(exports.float(min, max), exports.integer(min, max))(...as), IO.map(Or.clamp(N.Ord)(min, Math.max(min + Number.EPSILON, max - Number.EPSILON))));
+exports.number = number;
+exports.string = exports.fromIO(() => Math.random().toString(36).split('.')[1]);
+const literal = (a) => exports.of(a);
+exports.literal = literal;
+const unknown = (depth = 10) => function_2.recurse((_unknown, _depth) => (_depth < depth
+    ? union(_undefined, _null, exports.boolean, exports.number(), exports.string, exports.readonlyArray(_unknown), exports.readonlyRecord(exports.string, _unknown))
+    : union(_undefined, _null, exports.boolean, exports.number(), exports.string)));
+exports.unknown = unknown;
+const nullable = (M) => union(M, _undefined);
+exports.nullable = nullable;
+exports.tuple = _Apply.sequenceT(exports.Apply);
+exports.struct = _Apply.sequenceS(exports.Apply);
+const partial = (Ms) => function_1.pipe(Ms, RR.map(exports.nullable), exports.struct);
+exports.partial = partial;
+function union(...Ms) {
+    return function_1.pipe(Ms, R.randomElem, IO.chain(function_2.run), exports.fromIO);
+}
+exports.union = union;
+const readonlyArray = (M, min = 0, max = 10) => function_1.pipe(R.randomInt(Math.max(0, min), Math.max(0, min, max)), IO.map((n) => function_1.pipe($GL.fromIO(M()), $GL.takeLeft(n), $GL.toReadonlyArray)), exports.fromIO);
+exports.readonlyArray = readonlyArray;
+const readonlyNonEmptyArray = (M, min = 1, max = 10) => exports.readonlyArray(M, Math.max(1, min), Math.max(1, min, max));
+exports.readonlyNonEmptyArray = readonlyNonEmptyArray;
+const readonlyRecord = (KM, TM, min = 0, max = 10) => function_1.pipe(exports.readonlyArray(exports.tuple(KM, TM), Math.max(0, min), Math.max(0, min, max))(), IO.map(RR.fromFoldable(Se.last(), RA.Foldable)), exports.fromIO);
+exports.readonlyRecord = readonlyRecord;

package/lib/Option.d.ts

@@ -0,0 +1,2 @@
+import * as O from 'fp-ts/Option';
+export declare const toBoolean: <A>(ma: O.Option<A>) => ma is O.Some<A>;

package/lib/Option.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBoolean = void 0;
+const function_1 = require("fp-ts/function");
+const O = __importStar(require("fp-ts/Option"));
+const toBoolean = (ma) => O.exists(function_1.constTrue)(ma);
+exports.toBoolean = toBoolean;

package/lib/Random.d.ts

@@ -0,0 +1,7 @@
+import { Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from 'fp-ts/HKT';
+import * as IO from 'fp-ts/IO';
+import * as MIO from 'fp-ts/MonadIO';
+export declare function salt<M extends URIS4>(M: MIO.MonadIO4<M>): <S, R, E, A, B>(seed: IO.IO<A>, f: (salt: A) => Kind4<M, S, R, E, B>) => Kind4<M, S, R, E, B>;
+export declare function salt<M extends URIS3>(M: MIO.MonadIO3<M>): <R, E, A, B>(seed: IO.IO<A>, f: (salt: A) => Kind3<M, R, E, B>) => Kind3<M, R, E, B>;
+export declare function salt<M extends URIS2>(M: MIO.MonadIO2<M>): <E, A, B>(seed: IO.IO<A>, f: (salt: A) => Kind2<M, E, B>) => Kind2<M, E, B>;
+export declare function salt<M extends URIS>(M: MIO.MonadIO1<M>): <A, B>(seed: IO.IO<A>, f: (salt: A) => Kind<M, B>) => Kind<M, B>;

package/lib/Random.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.salt = void 0;
+function salt(M) {
+    return (seed, f) => M.chain(M.fromIO(seed), f);
+}
+exports.salt = salt;

package/lib/Reader.d.ts

@@ -0,0 +1,4 @@
+import * as R from 'fp-ts/Reader';
+export declare const pick: <R extends object>() => <K extends keyof R>(k: K) => R.Reader<Pick<R, K>, Pick<R, K>[K]>;
+export declare const picks: <R extends object>() => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => R.Reader<Pick<R, K>, B>) => R.Reader<Pick<R, K>, B>;
+export declare const picksW: <R1 extends object>() => <K extends keyof R1, R2, B>(k: K, f: (r: Pick<R1, K>[K]) => R.Reader<R2, B>) => R.Reader<Pick<R1, K> & R2, B>;

package/lib/Reader.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.picksW = exports.picks = exports.pick = void 0;
+const function_1 = require("fp-ts/function");
+const R = __importStar(require("fp-ts/Reader"));
+const $S = __importStar(require("./struct"));
+const pick = () => (k) => R.asks($S.lookup(k));
+exports.pick = pick;
+const picks = () => (k, f) => exports.picksW()(k, f);
+exports.picks = picks;
+const picksW = () => (k, f) => function_1.pipe(exports.pick()(k), R.chainW(f));
+exports.picksW = picksW;

package/lib/ReaderEither.d.ts

@@ -0,0 +1,9 @@
+import * as E from 'fp-ts/Either';
+import { Lazy } from 'fp-ts/function';
+import * as O from 'fp-ts/Option';
+import * as RE from 'fp-ts/ReaderEither';
+export declare const pick: <R extends object>() => <K extends keyof R>(k: K) => RE.ReaderEither<Pick<R, K>, never, Pick<R, K>[K]>;
+export declare const picks: <R extends object>() => <K extends keyof R, E, B>(k: K, f: (r: Pick<R, K>[K]) => RE.ReaderEither<Pick<R, K>, E, B>) => RE.ReaderEither<Pick<R, K>, E, B>;
+export declare const picksW: <R1 extends object>() => <K extends keyof R1, R2, E, B>(k: K, f: (r: Pick<R1, K>[K]) => RE.ReaderEither<R2, E, B>) => RE.ReaderEither<Pick<R1, K> & R2, E, B>;
+export declare const picksOptionK: <R extends object>() => <E>(onNone: Lazy<E>) => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => O.Option<B>) => RE.ReaderEither<Pick<R, K>, E, B>;
+export declare const picksEitherK: <R extends object>() => <K extends keyof R, _E, B>(k: K, f: (r: Pick<R, K>[K]) => E.Either<_E, B>) => RE.ReaderEither<Pick<R, K>, _E, B>;

package/lib/ReaderEither.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.picksEitherK = exports.picksOptionK = exports.picksW = exports.picks = exports.pick = void 0;
+const function_1 = require("fp-ts/function");
+const RE = __importStar(require("fp-ts/ReaderEither"));
+const pick = () => (k) => RE.asks((r) => r[k]);
+exports.pick = pick;
+const picks = () => (k, f) => exports.picksW()(k, f);
+exports.picks = picks;
+const picksW = () => (k, f) => function_1.pipe(exports.pick()(k), RE.chainW(f));
+exports.picksW = picksW;
+const picksOptionK = () => (onNone) => (k, f) => exports.picks()(k, RE.fromOptionK(onNone)(f));
+exports.picksOptionK = picksOptionK;
+const picksEitherK = () => (k, f) => exports.picks()(k, RE.fromEitherK(f));
+exports.picksEitherK = picksEitherK;

package/lib/ReaderTask.d.ts

@@ -0,0 +1,8 @@
+import * as IO from 'fp-ts/IO';
+import * as RT from 'fp-ts/ReaderTask';
+import * as T from 'fp-ts/Task';
+export declare const pick: <R extends object>() => <K extends keyof R>(k: K) => RT.ReaderTask<Pick<R, K>, Pick<R, K>[K]>;
+export declare const picks: <R extends object>() => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => RT.ReaderTask<Pick<R, K>, B>) => RT.ReaderTask<Pick<R, K>, B>;
+export declare const picksW: <R1 extends object>() => <K extends keyof R1, R2, B>(k: K, f: (r: Pick<R1, K>[K]) => RT.ReaderTask<R2, B>) => RT.ReaderTask<Pick<R1, K> & R2, B>;
+export declare const picksIOK: <R extends object>() => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => IO.IO<B>) => RT.ReaderTask<Pick<R, K>, B>;
+export declare const picksTaskK: <R extends object>() => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => T.Task<B>) => RT.ReaderTask<Pick<R, K>, B>;

package/lib/ReaderTask.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.picksTaskK = exports.picksIOK = exports.picksW = exports.picks = exports.pick = void 0;
+const function_1 = require("fp-ts/function");
+const RT = __importStar(require("fp-ts/ReaderTask"));
+const $S = __importStar(require("./struct"));
+const pick = () => (k) => RT.asks($S.lookup(k));
+exports.pick = pick;
+const picks = () => (k, f) => exports.picksW()(k, f);
+exports.picks = picks;
+const picksW = () => (k, f) => function_1.pipe(exports.pick()(k), RT.chainW(f));
+exports.picksW = picksW;
+const picksIOK = () => (k, f) => exports.picks()(k, RT.fromIOK(f));
+exports.picksIOK = picksIOK;
+const picksTaskK = () => (k, f) => exports.picks()(k, RT.fromTaskK(f));
+exports.picksTaskK = picksTaskK;

package/lib/ReaderTaskEither.d.ts

@@ -0,0 +1,17 @@
+import * as E from 'fp-ts/Either';
+import { Lazy } from 'fp-ts/function';
+import * as IO from 'fp-ts/IO';
+import * as IOE from 'fp-ts/IOEither';
+import * as O from 'fp-ts/Option';
+import * as RTE from 'fp-ts/ReaderTaskEither';
+import * as T from 'fp-ts/Task';
+import * as TE from 'fp-ts/TaskEither';
+export declare const pick: <R extends object>() => <K extends keyof R>(k: K) => RTE.ReaderTaskEither<Pick<R, K>, never, Pick<R, K>[K]>;
+export declare const picks: <R extends object>() => <K extends keyof R, E, B>(k: K, f: (r: Pick<R, K>[K]) => RTE.ReaderTaskEither<Pick<R, K>, E, B>) => RTE.ReaderTaskEither<Pick<R, K>, E, B>;
+export declare const picksW: <R1 extends object>() => <K extends keyof R1, R2, E, B>(k: K, f: (r: Pick<R1, K>[K]) => RTE.ReaderTaskEither<R2, E, B>) => RTE.ReaderTaskEither<Pick<R1, K> & R2, E, B>;
+export declare const picksOptionK: <R extends object>() => <E>(onNone: Lazy<E>) => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => O.Option<B>) => RTE.ReaderTaskEither<Pick<R, K>, E, B>;
+export declare const picksEitherK: <R extends object>() => <K extends keyof R, _E, B>(k: K, f: (r: Pick<R, K>[K]) => E.Either<_E, B>) => RTE.ReaderTaskEither<Pick<R, K>, _E, B>;
+export declare const picksIOK: <R extends object>() => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => IO.IO<B>) => RTE.ReaderTaskEither<Pick<R, K>, never, B>;
+export declare const picksIOEitherK: <R extends object>() => <K extends keyof R, _E, B>(k: K, f: (r: Pick<R, K>[K]) => IOE.IOEither<_E, B>) => RTE.ReaderTaskEither<Pick<R, K>, _E, B>;
+export declare const picksTaskK: <R extends object>() => <K extends keyof R, B>(k: K, f: (r: Pick<R, K>[K]) => T.Task<B>) => RTE.ReaderTaskEither<Pick<R, K>, never, B>;
+export declare const picksTaskEitherK: <R extends object>() => <K extends keyof R, _E, B>(k: K, f: (r: Pick<R, K>[K]) => TE.TaskEither<_E, B>) => RTE.ReaderTaskEither<Pick<R, K>, _E, B>;

package/lib/ReaderTaskEither.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.picksTaskEitherK = exports.picksTaskK = exports.picksIOEitherK = exports.picksIOK = exports.picksEitherK = exports.picksOptionK = exports.picksW = exports.picks = exports.pick = void 0;
+const function_1 = require("fp-ts/function");
+const RTE = __importStar(require("fp-ts/ReaderTaskEither"));
+const pick = () => (k) => RTE.asks((r) => r[k]);
+exports.pick = pick;
+const picks = () => (k, f) => exports.picksW()(k, f);
+exports.picks = picks;
+const picksW = () => (k, f) => function_1.pipe(exports.pick()(k), RTE.chainW(f));
+exports.picksW = picksW;
+const picksOptionK = () => (onNone) => (k, f) => exports.picks()(k, RTE.fromOptionK(onNone)(f));
+exports.picksOptionK = picksOptionK;
+const picksEitherK = () => (k, f) => exports.picks()(k, RTE.fromEitherK(f));
+exports.picksEitherK = picksEitherK;
+const picksIOK = () => (k, f) => function_1.pipe(exports.pick()(k), RTE.chainIOK(f));
+exports.picksIOK = picksIOK;
+const picksIOEitherK = () => (k, f) => exports.picks()(k, RTE.fromIOEitherK(f));
+exports.picksIOEitherK = picksIOEitherK;
+const picksTaskK = () => (k, f) => function_1.pipe(exports.pick()(k), RTE.chainTaskK(f));
+exports.picksTaskK = picksTaskK;
+const picksTaskEitherK = () => (k, f) => exports.picks()(k, RTE.fromTaskEitherK(f));
+exports.picksTaskEitherK = picksTaskEitherK;

package/lib/ReadonlyArray.d.ts

@@ -0,0 +1,75 @@
+import * as E from 'fp-ts/Eq';
+import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
+/**
+ * {@link https://en.wikipedia.org/wiki/Cartesian_product}
+ */
+export declare const cartesian: <T extends (readonly any[])[]>(...t: T & {
+    readonly 0: readonly any[];
+}) => readonly { [K in keyof T]: [T[K]] extends [readonly (infer A)[]] ? A : never; }[];
+/**
+ * {@link https://en.wikipedia.org/wiki/Word_(group_theory)}
+ *
+ * @example
+ * import { readonlyArray } from 'fp-ts'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * // https://en.wikipedia.org/wiki/Rock_paper_scissors#Additional_weapons
+ * const shapes = ['Rock', 'Paper', 'Scissors', 'Spock', 'Lizard'] as const
+ * const win = (a: number, b: number): boolean =>
+ *   !!{ 1: true, 3: true }[(5 + a - b) % 5]
+ *
+ * expect(
+ *   pipe(
+ *     shapes,
+ *     readonlyArray.mapWithIndex((i, a) => [i, a] as const),
+ *     words(2),
+ *     readonlyArray.filter(([[a], [b]]) => win(a, b)),
+ *     readonlyArray.map(([[, a], [, b]]) => `${a} defeats ${b}`)
+ *   )
+ * ).toStrictEqual([
+ *   'Rock defeats Scissors',
+ *   'Rock defeats Lizard',
+ *   'Paper defeats Rock',
+ *   'Paper defeats Spock',
+ *   'Scissors defeats Paper',
+ *   'Scissors defeats Lizard',
+ *   'Spock defeats Rock',
+ *   'Spock defeats Scissors',
+ *   'Lizard defeats Paper',
+ *   'Lizard defeats Spock',
+ * ])
+ */
+export declare function words<A>(size: 3): (alphabeth: ReadonlyArray<A>) => ReadonlyArray<Readonly<[A, A, A]>>;
+export declare function words<A>(size: 2): (alphabeth: ReadonlyArray<A>) => ReadonlyArray<Readonly<[A, A]>>;
+export declare function words<A>(size: 1): (alphabeth: ReadonlyArray<A>) => ReadonlyArray<Readonly<[A]>>;
+export declare function words<A>(size: number): (alphabeth: ReadonlyArray<A>) => Readonly<[Readonly<[]>]> | ReadonlyArray<Readonly<[A, ...ReadonlyArray<A>]>>;
+export declare const allElems: <A>(E: E.Eq<A>) => (...elems: RNEA.ReadonlyNonEmptyArray<A>) => (as: readonly A[]) => as is RNEA.ReadonlyNonEmptyArray<A>;
+export declare const anyElem: <A>(E: E.Eq<A>) => (...elems: RNEA.ReadonlyNonEmptyArray<A>) => (as: readonly A[]) => as is RNEA.ReadonlyNonEmptyArray<A>;
+/**
+ * @example
+ * import { eq, string } from 'fp-ts'
+ * import { Eq } from 'fp-ts/Eq'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * type User = { name: string; mother: string; father: string }
+ *
+ * const eqParents: Eq<User> = pipe(
+ *   eq.tuple(string.Eq, string.Eq),
+ *   eq.contramap(({ mother, father }) => [mother, father] as const)
+ * )
+ * const siblings = same(eqParents)
+ *
+ * expect(
+ *   siblings([
+ *     { name: 'Thomas', mother: 'Edith', father: 'Matthew' },
+ *     { name: 'Thomas', mother: 'Edith', father: 'Richard' },
+ *   ])
+ * ).toBe(false)
+ * expect(
+ *   siblings([
+ *     { name: 'Thomas', mother: 'Edith', father: 'Matthew' },
+ *     { name: 'William', mother: 'Edith', father: 'Matthew' },
+ *   ])
+ * ).toBe(true)
+ */
+export declare const same: <A>(E: E.Eq<A>) => (as: readonly A[]) => boolean;

package/lib/ReadonlyArray.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.same = exports.anyElem = exports.allElems = exports.words = exports.cartesian = void 0;
+const Ap = __importStar(require("fp-ts/Apply"));
+const function_1 = require("fp-ts/function");
+const RA = __importStar(require("fp-ts/ReadonlyArray"));
+const $E = __importStar(require("./Eq"));
+const function_2 = require("./function");
+/**
+ * {@link https://en.wikipedia.org/wiki/Cartesian_product}
+ */
+exports.cartesian = Ap.sequenceT(RA.Apply);
+function words(size) {
+    return (alphabet) => size < 1
+        ? [[]]
+        : function_1.pipe(alphabet, function_2.curry(RA.replicate)(size), ([head, ...tail]) => exports.cartesian(head, ...tail));
+}
+exports.words = words;
+const allElems = (E) => (...elems) => (as) => function_1.pipe(elems, RA.intersection(E)(as), function_2.curry($E.getEqSize(RA).equals)(elems));
+exports.allElems = allElems;
+const anyElem = (E) => (...elems) => (as) => function_1.pipe(elems, RA.some((elem) => function_1.pipe(as, RA.elem(E)(elem))));
+exports.anyElem = anyElem;
+/**
+ * @example
+ * import { eq, string } from 'fp-ts'
+ * import { Eq } from 'fp-ts/Eq'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * type User = { name: string; mother: string; father: string }
+ *
+ * const eqParents: Eq<User> = pipe(
+ *   eq.tuple(string.Eq, string.Eq),
+ *   eq.contramap(({ mother, father }) => [mother, father] as const)
+ * )
+ * const siblings = same(eqParents)
+ *
+ * expect(
+ *   siblings([
+ *     { name: 'Thomas', mother: 'Edith', father: 'Matthew' },
+ *     { name: 'Thomas', mother: 'Edith', father: 'Richard' },
+ *   ])
+ * ).toBe(false)
+ * expect(
+ *   siblings([
+ *     { name: 'Thomas', mother: 'Edith', father: 'Matthew' },
+ *     { name: 'William', mother: 'Edith', father: 'Matthew' },
+ *   ])
+ * ).toBe(true)
+ */
+const same = (E) => (as) => function_1.pipe(as, RA.matchLeft(function_1.constTrue, (head, tail) => function_1.pipe(tail, RA.every(function_2.curry(E.equals)(head)))));
+exports.same = same;

package/lib/ReadonlyRecord.d.ts

@@ -0,0 +1,4 @@
+import * as E from 'fp-ts/Eq';
+import * as RR from 'fp-ts/ReadonlyRecord';
+export declare const values: <A>(as: Readonly<Record<string, A>>) => readonly A[];
+export declare const same: <A>(E: E.Eq<A>) => (as: Readonly<Record<string, A>>) => boolean;

package/lib/ReadonlyRecord.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.same = exports.values = void 0;
+const function_1 = require("fp-ts/function");
+const $RA = __importStar(require("./ReadonlyArray"));
+const values = (as) => Object.values(as);
+exports.values = values;
+const same = (E) => (as) => function_1.pipe(as, exports.values, $RA.same(E));
+exports.same = same;

package/lib/ReadonlyTuple.d.ts

@@ -0,0 +1,14 @@
+import * as A from 'fp-ts/Applicative';
+import { Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from 'fp-ts/HKT';
+export declare const sequenceFst: import("fp-ts/lib/Traversable").Sequence2<"ReadonlyTuple">;
+export declare function sequenceSnd<F extends URIS4>(F: A.Applicative4<F>): <TE, S, R, FE, A>(ta: Readonly<[TE, Kind4<F, S, R, FE, A>]>) => Kind4<F, S, R, FE, Readonly<[TE, A]>>;
+export declare function sequenceSnd<F extends URIS3>(F: A.Applicative3<F>): <TE, R, FE, A>(ta: Readonly<[TE, Kind3<F, R, FE, A>]>) => Kind3<F, R, FE, Readonly<[TE, A]>>;
+export declare function sequenceSnd<F extends URIS3, FE>(F: A.Applicative3C<F, FE>): <TE, R, A>(ta: Readonly<[TE, Kind3<F, R, FE, A>]>) => Kind3<F, R, FE, Readonly<[TE, A]>>;
+export declare function sequenceSnd<F extends URIS2>(F: A.Applicative2<F>): <TE, FE, A>(ta: Readonly<[TE, Kind2<F, FE, A>]>) => Kind2<F, FE, Readonly<[TE, A]>>;
+export declare function sequenceSnd<F extends URIS2, FE>(F: A.Applicative2C<F, FE>): <TE, A>(ta: Readonly<[TE, Kind2<F, FE, A>]>) => Kind2<F, FE, Readonly<[TE, A]>>;
+export declare function sequenceSnd<F extends URIS>(F: A.Applicative1<F>): <TE, A>(ta: Readonly<[TE, Kind<F, A>]>) => Kind<F, Readonly<[TE, A]>>;
+export declare const traverseFst: import("fp-ts/lib/Traversable").PipeableTraverse2<"ReadonlyTuple">;
+export declare function traverseSnd<F extends URIS3>(F: A.Applicative3<F>): <A, FR, FE, B>(f: (a: A) => Kind3<F, FR, FE, B>) => <TE>(ta: Readonly<[TE, A]>) => Kind3<F, FR, FE, Readonly<[TE, B]>>;
+export declare function traverseSnd<F extends URIS2>(F: A.Applicative2<F>): <A, FE, B>(f: (a: A) => Kind2<F, FE, B>) => <TE>(ta: Readonly<[TE, A]>) => Kind2<F, FE, Readonly<[TE, B]>>;
+export declare function traverseSnd<F extends URIS2, FE>(F: A.Applicative2C<F, FE>): <A, B>(f: (a: A) => Kind2<F, FE, B>) => <TE>(ta: Readonly<[TE, A]>) => Kind2<F, FE, Readonly<[TE, B]>>;
+export declare function traverseSnd<F extends URIS>(F: A.Applicative1<F>): <A, B>(f: (a: A) => Kind<F, B>) => <TE>(ta: Readonly<[TE, A]>) => Kind<F, Readonly<[TE, B]>>;

package/lib/ReadonlyTuple.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSnd = exports.traverseFst = exports.sequenceSnd = exports.sequenceFst = void 0;
+const function_1 = require("fp-ts/function");
+const RT = __importStar(require("fp-ts/ReadonlyTuple"));
+exports.sequenceFst = RT.sequence;
+function sequenceSnd(F) {
+    return (ta) => function_1.pipe(ta, RT.swap, RT.sequence(F), (fa) => F.map(fa, RT.swap));
+}
+exports.sequenceSnd = sequenceSnd;
+exports.traverseFst = RT.traverse;
+function traverseSnd(F) {
+    return (f) => (ta) => function_1.pipe(ta, RT.swap, RT.traverse(F)(f), (fa) => F.map(fa, RT.swap));
+}
+exports.traverseSnd = traverseSnd;

package/lib/Storage.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import * as TE from 'fp-ts/TaskEither';
+import * as $L from './Log';
+export interface Storage {
+    readonly getStream: (path: string, options?: StorageOptions) => TE.TaskEither<Error, NodeJS.ReadableStream>;
+    readonly getUrl: (path: string, options?: StorageOptions) => TE.TaskEither<Error, string>;
+    readonly read: (path: string, options?: StorageOptions) => TE.TaskEither<Error, Buffer>;
+    readonly write: (path: string, options?: StorageOptions) => (data: Buffer | NodeJS.ReadableStream) => TE.TaskEither<Error, void>;
+    readonly delete: (path: string, options?: StorageOptions) => TE.TaskEither<Error, void>;
+}
+interface StorageOptions {
+    readonly fileSystem?: string;
+}
+export declare const log: (logStart: $L.Logger, logEnd?: $L.Logger) => (storage: Storage) => Storage;
+export {};