fortepiano 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# fortepiano
+[![main](https://github.com/facile-it/fortepiano/actions/workflows/main.yaml/badge.svg)](https://github.com/facile-it/fortepiano/actions/workflows/main.yaml)
+[![codecov](https://codecov.io/gh/facile-it/fortepiano/branch/master/graph/badge.svg?token=GRJ7ANG8WS)](https://codecov.io/gh/facile-it/fortepiano)

package/lib/Aggregate.d.ts

@@ -0,0 +1,4 @@
+export interface Aggregate<A> {
+    isEmpty: (a: A) => boolean;
+    size: (a: A) => number;
+}

package/lib/Aggregate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Binary.d.ts

@@ -0,0 +1,5 @@
+import * as M from 'fp-ts/Monoid';
+export declare type Binary = 0 | 1;
+export declare const MonoidAnd: M.Monoid<Binary>;
+export declare const MonoidOr: M.Monoid<Binary>;
+export declare const MonoidXor: M.Monoid<Binary>;

package/lib/Binary.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonoidXor = exports.MonoidOr = exports.MonoidAnd = void 0;
+exports.MonoidAnd = {
+    empty: 1,
+    concat: (x, y) => Number(Boolean(x) && Boolean(y)),
+};
+exports.MonoidOr = {
+    empty: 0,
+    concat: (x, y) => Number(Boolean(x) || Boolean(y)),
+};
+exports.MonoidXor = {
+    empty: 0,
+    concat: (x, y) => Number(x ? !y : Boolean(y)),
+};

package/lib/Buffer.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import * as t from 'io-ts';
+export declare const BufferC: t.Type<Buffer, string, unknown>;
+export declare const BufferFromStringC: t.Type<Buffer, string, unknown>;
+export declare const fromStream: (stream: NodeJS.ReadableStream) => import("fp-ts/lib/TaskEither").TaskEither<Error, Buffer>;

package/lib/Buffer.js

@@ -0,0 +1,45 @@
+"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.fromStream = exports.BufferFromStringC = exports.BufferC = void 0;
+const t = __importStar(require("io-ts"));
+const $E = __importStar(require("./Error"));
+const $TE = __importStar(require("./TaskEither"));
+const is = (u) => u instanceof Buffer;
+exports.BufferC = new t.Type('Buffer', is, (u, c) => (is(u) ? t.success(u) : t.failure(u, c)), (b) => b.toString('base64'));
+exports.BufferFromStringC = new t.Type('BufferFromString', is, (u, c) => {
+    try {
+        return t.string.is(u)
+            ? t.success(Buffer.from(u, 'base64'))
+            : t.failure(u, c);
+    }
+    catch (_) {
+        return t.failure(u, c);
+    }
+}, exports.BufferC.encode);
+const fromStream = (stream) => $TE.tryCatch(() => new Promise((resolve, reject) => {
+    const buffer = [];
+    stream
+        .on('error', reject)
+        .on('data', (data) => buffer.push(data))
+        .on('end', () => resolve(Buffer.concat(buffer)));
+}), $E.fromUnknown(Error('Cannot read stream into buffer')));
+exports.fromStream = fromStream;

package/lib/Cache.d.ts

@@ -0,0 +1,18 @@
+import { Endomorphism } from 'fp-ts/function';
+import * as J from 'fp-ts/Json';
+import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
+import * as TE from 'fp-ts/TaskEither';
+import * as t from 'io-ts';
+import { memory } from './cache/Memory';
+import { storage } from './cache/Storage';
+import * as $L from './Log';
+export interface Cache {
+    readonly get: <A>(key: string, codec: t.Type<A, unknown>) => TE.TaskEither<Error, A>;
+    readonly set: <A>(key: string, codec: t.Type<A, J.Json>, ttl?: number) => (value: A) => TE.TaskEither<Error, void>;
+    readonly delete: (key: string) => TE.TaskEither<Error, void>;
+    readonly clear: TE.TaskEither<Error, void>;
+}
+export declare const chain: (...caches: RNEA.ReadonlyNonEmptyArray<Cache>) => Cache;
+export declare function log(logStart: $L.Logger, logEnd: $L.Logger): Endomorphism<Cache>;
+export declare function log(log: $L.Logger): Endomorphism<Cache>;
+export { memory, storage };

package/lib/Cache.js

@@ -0,0 +1,50 @@
+"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.storage = exports.memory = exports.log = exports.chain = void 0;
+const function_1 = require("fp-ts/function");
+const R = __importStar(require("fp-ts/Random"));
+const RNEA = __importStar(require("fp-ts/ReadonlyNonEmptyArray"));
+const TE = __importStar(require("fp-ts/TaskEither"));
+const Memory_1 = require("./cache/Memory");
+Object.defineProperty(exports, "memory", { enumerable: true, get: function () { return Memory_1.memory; } });
+const Storage_1 = require("./cache/Storage");
+Object.defineProperty(exports, "storage", { enumerable: true, get: function () { return Storage_1.storage; } });
+const $L = __importStar(require("./Log"));
+const $R = __importStar(require("./Random"));
+const chain = (...caches) => ({
+    get: (key, codec) => function_1.pipe(caches, RNEA.reduce(TE.left(Error()), (value, { get }) => TE.Alt.alt(value, () => get(key, codec)))),
+    set: (key, codec, ttl) => (value) => function_1.pipe(caches, TE.traverseArray(({ set }) => set(key, codec, ttl)(value)), TE.map(function_1.constVoid)),
+    delete: (key) => function_1.pipe(caches, TE.traverseArray(({ delete: _delete }) => _delete(key)), TE.map(function_1.constVoid)),
+    clear: function_1.pipe(caches, TE.traverseArray(({ clear }) => clear), TE.map(function_1.constVoid)),
+});
+exports.chain = chain;
+function log(log0, log1) {
+    const logStart = undefined !== log1 ? log0 : $L.void;
+    const logEnd = log1 || log0;
+    return (cache) => ({
+        get: (key, codec) => $R.salt(TE.MonadIO)(R.randomInt(0, Number.MAX_SAFE_INTEGER), (salt) => function_1.pipe(logStart(`[${salt}] \rItem "${key}" retrieved from cache`), TE.fromIO, TE.chain(() => cache.get(key, codec)), TE.chainFirstIOK(() => logEnd(`[${salt}] \rItem "${key}" retrieved from cache`)))),
+        set: (key, codec, ttl) => (value) => $R.salt(TE.MonadIO)(R.randomInt(0, Number.MAX_SAFE_INTEGER), (salt) => function_1.pipe(logStart(`[${salt}] \rItem "${key}" saved to cache`), TE.fromIO, TE.chain(() => cache.set(key, codec, ttl)(value)), TE.chainFirstIOK(() => logEnd(`[${salt}] \rItem "${key}" saved to cache`)))),
+        delete: (key) => $R.salt(TE.MonadIO)(R.randomInt(0, Number.MAX_SAFE_INTEGER), (salt) => function_1.pipe(logStart(`[${salt}] \rItem "${key}" deleted from cache`), TE.fromIO, TE.chain(() => cache.delete(key)), TE.chainFirstIOK(() => logEnd(`[${salt}] \rItem "${key}" deleted from cache`)))),
+        clear: $R.salt(TE.MonadIO)(R.randomInt(0, Number.MAX_SAFE_INTEGER), (salt) => function_1.pipe(logStart(`[${salt}] \rCache cleared`), TE.fromIO, TE.chain(() => cache.clear), TE.chainFirstIOK(() => logEnd(`[${salt}] \rCache cleared`)))),
+    });
+}
+exports.log = log;

package/lib/Console.d.ts

@@ -0,0 +1,20 @@
+import * as IO from 'fp-ts/IO';
+import * as RR from 'fp-ts/ReadonlyRecord';
+import * as $S from './struct';
+export declare const error: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const info: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const log: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const trace: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const warn: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const assert: (condition?: boolean | undefined, ...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const count: (a?: unknown) => IO.IO<void>;
+export declare const countReset: (a?: unknown) => IO.IO<void>;
+export declare const group: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const groupCollapsed: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
+export declare const groupEnd: IO.IO<void>;
+export declare function table<A extends $S.struct, K extends keyof A>(data: ReadonlyArray<A> | RR.ReadonlyRecord<string, A>, columns?: ReadonlyArray<K>): IO.IO<void>;
+export declare function table(data: $S.struct | ReadonlyArray<unknown>): IO.IO<void>;
+export declare function table(a?: undefined | boolean | number | string, ...as: ReadonlyArray<unknown>): IO.IO<void>;
+export declare const time: (a?: unknown) => IO.IO<void>;
+export declare const timeEnd: (a?: unknown) => IO.IO<void>;
+export declare const timeLog: (a?: unknown) => IO.IO<void>;

package/lib/Console.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeLog = exports.timeEnd = exports.time = exports.table = exports.groupEnd = exports.groupCollapsed = exports.group = exports.countReset = exports.count = exports.assert = exports.warn = exports.trace = exports.log = exports.info = exports.error = void 0;
+const _noArgs = (method) => () => console[method]();
+const _singleArg = (method) => (a) => () => console[method](a);
+const _multipleArgs = (method) => (...as) => () => console[method](...as);
+exports.error = _multipleArgs('error');
+exports.info = _multipleArgs('info');
+exports.log = _multipleArgs('log');
+exports.trace = _multipleArgs('trace');
+exports.warn = _multipleArgs('warn');
+const assert = (condition, ...as) => () => console.assert(condition, ...as);
+exports.assert = assert;
+exports.count = _singleArg('count');
+exports.countReset = _singleArg('countReset');
+exports.group = _multipleArgs('group');
+exports.groupCollapsed = _multipleArgs('groupCollapsed');
+exports.groupEnd = _noArgs('groupEnd');
+function table(...args) {
+    return () => console.table(...args);
+}
+exports.table = table;
+exports.time = _singleArg('time');
+exports.timeEnd = _singleArg('timeEnd');
+exports.timeLog = _singleArg('timeLog');

package/lib/Crypto.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import * as TE from 'fp-ts/TaskEither';
+export declare const randomBytes: (size: number) => TE.TaskEither<Error, Buffer>;
+export declare const hash: (size: number, encoding?: BufferEncoding) => TE.TaskEither<Error, string>;
+export declare const uuid4: TE.TaskEither<Error, string>;

package/lib/Crypto.js

@@ -0,0 +1,39 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid4 = exports.hash = exports.randomBytes = void 0;
+/* eslint-disable no-bitwise */
+const crypto_1 = __importDefault(require("crypto"));
+const function_1 = require("fp-ts/function");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const $E = __importStar(require("./Error"));
+const randomBytes = (size) => function_1.pipe(TE.tryCatch(() => new Promise((resolve, reject) => crypto_1.default.randomBytes(size, (error, buffer) => null !== error ? reject(error) : resolve(buffer))), $E.fromUnknown(Error(`Cannot generate ${size} random bytes`))));
+exports.randomBytes = randomBytes;
+const hash = (size, encoding = 'hex') => function_1.pipe(exports.randomBytes(size), TE.map((buffer) => buffer.toString(encoding)));
+exports.hash = hash;
+exports.uuid4 = function_1.pipe(exports.hash(16, 'hex'), TE.map((s) => `${s.slice(0, 8)}-${s.slice(8, 12)}-4${s.slice(13, 16)}-${(((s.charCodeAt(16) > 57
+    ? s.charCodeAt(16) - 97
+    : s.charCodeAt(16) - 48) &
+    0x3) |
+    0x8).toString(16)}${s.slice(17, 20)}-${s.slice(20)}`));

package/lib/Date.d.ts

@@ -0,0 +1,4 @@
+import * as O from 'fp-ts/Option';
+export declare const fromDate: (date: Date) => O.Option<Date>;
+export declare const fromString: (date: string) => O.Option<Date>;
+export declare const parse: (date: string) => O.Option<number>;

package/lib/Date.js

@@ -0,0 +1,30 @@
+"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.parse = exports.fromString = exports.fromDate = void 0;
+const function_1 = require("fp-ts/function");
+const O = __importStar(require("fp-ts/Option"));
+const fromDate = (date) => isFinite(date) ? O.some(date) : O.none;
+exports.fromDate = fromDate;
+const fromString = (date) => function_1.pipe(new Date(date), exports.fromDate);
+exports.fromString = fromString;
+const parse = (date) => function_1.pipe(date, Date.parse, O.of, O.filter(isFinite));
+exports.parse = parse;

package/lib/Eq.d.ts

@@ -0,0 +1,4 @@
+import * as E from 'fp-ts/Eq';
+import * as $A from './Aggregate';
+export declare const eqType: E.Eq<unknown>;
+export declare const getEqSize: <T>(A: $A.Aggregate<T>) => E.Eq<T>;

package/lib/Eq.js

@@ -0,0 +1,29 @@
+"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.getEqSize = exports.eqType = void 0;
+const E = __importStar(require("fp-ts/Eq"));
+const function_1 = require("fp-ts/function");
+const N = __importStar(require("fp-ts/number"));
+const S = __importStar(require("fp-ts/string"));
+exports.eqType = function_1.pipe(S.Eq, E.contramap((a) => typeof a));
+const getEqSize = (A) => function_1.pipe(N.Eq, E.contramap(A.size));
+exports.getEqSize = getEqSize;

package/lib/Error.d.ts

@@ -0,0 +1,6 @@
+import * as t from 'io-ts';
+export declare const ErrorC: t.Type<Error, string, unknown>;
+export declare const fromUnknown: (e: Error) => (u: unknown) => Error;
+export declare const wrap: (e: Error) => (u: unknown) => Error & {
+    readonly prev?: Error;
+};

package/lib/Error.js

@@ -0,0 +1,56 @@
+"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.wrap = exports.fromUnknown = exports.ErrorC = void 0;
+const function_1 = require("fp-ts/function");
+const O = __importStar(require("fp-ts/Option"));
+const t = __importStar(require("io-ts"));
+const PathReporter_1 = require("io-ts/PathReporter");
+const $S = __importStar(require("./struct"));
+const is = (u) => t
+    .intersection([
+    t.type({ name: t.string, message: t.string }),
+    t.partial({ stack: t.string }),
+])
+    .is(u) || u instanceof Error;
+exports.ErrorC = new t.Type('Error', is, (u, c) => (is(u) ? t.success(u) : t.failure(u, c)), $S.lookup('message'));
+const _fromUnknown = (u) => {
+    try {
+        // eslint-disable-next-line no-nested-ternary
+        return exports.ErrorC.is(u)
+            ? O.some(u)
+            : t.string.is(u)
+                ? O.some(Error(u))
+                : O.some(Error(PathReporter_1.failure(u).join('\n')));
+    }
+    catch (_) {
+        return O.none;
+    }
+};
+const fromUnknown = (e) => function_1.flow(_fromUnknown, O.getOrElse(() => e));
+exports.fromUnknown = fromUnknown;
+const withPrev = (prev) => (error) => {
+    ;
+    error.prev = prev;
+    return error;
+};
+const wrap = (e) => (u) => function_1.pipe(u, _fromUnknown, O.match(() => e, (error) => withPrev(error)(e)));
+exports.wrap = wrap;

package/lib/GeneratorL.d.ts

@@ -0,0 +1,208 @@
+import * as $generatorL from 'fp-ts/Alt';
+import * as Alte from 'fp-ts/Alternative';
+import * as Appli from 'fp-ts/Applicative';
+import * as _Apply from 'fp-ts/Apply';
+import * as Ch from 'fp-ts/Chain';
+import * as Co from 'fp-ts/Compactable';
+import * as Ei from 'fp-ts/Either';
+import * as Eq from 'fp-ts/Eq';
+import * as Ex from 'fp-ts/Extend';
+import * as Fi from 'fp-ts/Filterable';
+import * as FiWI from 'fp-ts/FilterableWithIndex';
+import * as Fo from 'fp-ts/Foldable';
+import * as FoWI from 'fp-ts/FoldableWithIndex';
+import * as FIO from 'fp-ts/FromIO';
+import { Lazy, Predicate, Refinement } from 'fp-ts/function';
+import * as Fu from 'fp-ts/Functor';
+import * as FuWI from 'fp-ts/FunctorWithIndex';
+import { Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from 'fp-ts/HKT';
+import * as IO from 'fp-ts/IO';
+import * as Mona from 'fp-ts/Monad';
+import * as MIO from 'fp-ts/MonadIO';
+import * as Mono from 'fp-ts/Monoid';
+import * as Op from 'fp-ts/Option';
+import * as Or from 'fp-ts/Ord';
+import * as P from 'fp-ts/Pointed';
+import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
+import * as S from 'fp-ts/Separated';
+import * as T from 'fp-ts/Traversable';
+import * as TWI from 'fp-ts/TraversableWithIndex';
+import * as U from 'fp-ts/Unfoldable';
+import * as W from 'fp-ts/Witherable';
+import { Int } from 'io-ts';
+export declare const URI = "GeneratorL";
+export declare type URI = typeof URI;
+declare module 'fp-ts/HKT' {
+    interface URItoKind<A> {
+        [URI]: GeneratorL<A>;
+    }
+}
+export declare type GeneratorL<A> = Lazy<Generator<A>>;
+export declare const getMonoid: <A>() => Mono.Monoid<GeneratorL<A>>;
+export declare const getEq: <A>(E: Eq.Eq<A>) => Eq.Eq<GeneratorL<A>>;
+export declare const getOrd: <A>(O: Or.Ord<A>) => Or.Ord<GeneratorL<A>>;
+export declare const Functor: Fu.Functor1<URI>;
+export declare const map: <A, B>(a: (a: A) => B) => (b: GeneratorL<A>) => GeneratorL<B>;
+export declare const flap: <A>(a: A) => <B>(fab: GeneratorL<(a: A) => B>) => GeneratorL<B>;
+export declare const bindTo: <N extends string>(name: N) => <A>(fa: GeneratorL<A>) => GeneratorL<{ readonly [K in N]: A; }>;
+export declare const Pointed: P.Pointed1<URI>;
+export declare const of: <A>(a: A) => GeneratorL<A>;
+export declare const Do: GeneratorL<{}>;
+export declare const FunctorWithIndex: FuWI.FunctorWithIndex1<URI, number>;
+export declare const mapWithIndex: <A, B>(a: (i: number, a: A) => B) => (b: GeneratorL<A>) => GeneratorL<B>;
+export declare const Apply: _Apply.Apply1<URI>;
+export declare const ap: <A, B>(a: GeneratorL<A>) => (b: GeneratorL<(a: A) => B>) => GeneratorL<B>;
+export declare const apFirst: <B>(second: GeneratorL<B>) => <A>(first: GeneratorL<A>) => GeneratorL<A>;
+export declare const apSecond: <B>(second: GeneratorL<B>) => <A>(first: GeneratorL<A>) => GeneratorL<B>;
+export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: GeneratorL<B>) => (fa: GeneratorL<A>) => GeneratorL<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const Applicative: Appli.Applicative1<URI>;
+export declare const Chain: Ch.Chain1<URI>;
+export declare const chain: <A, B>(a: (a: A) => GeneratorL<B>) => (b: GeneratorL<A>) => GeneratorL<B>;
+export declare const chainFirst: <A, B>(f: (a: A) => GeneratorL<B>) => (first: GeneratorL<A>) => GeneratorL<A>;
+export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => GeneratorL<B>) => (ma: GeneratorL<A>) => GeneratorL<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const chainWithIndex: <A, B>(f: (i: number, a: A) => GeneratorL<B>) => (fa: GeneratorL<A>) => GeneratorL<B>;
+export declare const Monad: Mona.Monad1<URI>;
+export declare const FromIO: FIO.FromIO1<URI>;
+export declare const fromIO: import("fp-ts/lib/NaturalTransformation").NaturalTransformation11<"IO", "GeneratorL">;
+export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<B>) => (...a: A) => GeneratorL<B>;
+export declare const chainIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: GeneratorL<A>) => GeneratorL<B>;
+export declare const chainFirstIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: GeneratorL<A>) => GeneratorL<A>;
+export declare const MonadIO: MIO.MonadIO1<URI>;
+export declare const Unfoldable: U.Unfoldable1<URI>;
+export declare const unfold: <A, B>(a: (b: B) => Op.Option<[A, B]>) => (b: B) => GeneratorL<A>;
+export declare const Alt: $generatorL.Alt1<URI>;
+export declare const alt: <A>(a: Lazy<GeneratorL<A>>) => (b: GeneratorL<A>) => GeneratorL<A>;
+export declare const Alternative: Alte.Alternative1<URI>;
+export declare const zero: <A>() => GeneratorL<A>;
+export declare const Extend: Ex.Extend1<URI>;
+export declare const extend: <A, B>(a: (wa: GeneratorL<A>) => B) => (b: GeneratorL<A>) => GeneratorL<B>;
+export declare const duplicate: <A>(fa: GeneratorL<A>) => GeneratorL<GeneratorL<A>>;
+export declare const Compactable: Co.Compactable1<URI>;
+export declare const compact: <A>(fa: GeneratorL<Op.Option<A>>) => GeneratorL<A>;
+export declare const separate: <A, B>(fa: GeneratorL<Ei.Either<A, B>>) => S.Separated<GeneratorL<A>, GeneratorL<B>>;
+export declare const Filterable: Fi.Filterable1<URI>;
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (fa: GeneratorL<A>) => GeneratorL<B>;
+export declare function filter<A>(predicate: Predicate<A>): (fa: GeneratorL<A>) => GeneratorL<A>;
+export declare const filterMap: <A, B>(a: (a: A) => Op.Option<B>) => (b: GeneratorL<A>) => GeneratorL<B>;
+export declare function partition<A, B extends A>(refinement: Refinement<A, B>): (fa: GeneratorL<A>) => S.Separated<GeneratorL<A>, GeneratorL<B>>;
+export declare function partition<A>(predicate: Predicate<A>): (fa: GeneratorL<A>) => S.Separated<GeneratorL<A>, GeneratorL<A>>;
+export declare const partitionMap: <A, B, C>(a: (a: A) => Ei.Either<B, C>) => (b: GeneratorL<A>) => S.Separated<GeneratorL<B>, GeneratorL<C>>;
+export declare const FilterableWithIndex: FiWI.FilterableWithIndex1<URI, number>;
+export declare function filterWithIndex<A, B extends A>(refinementWithIndex: (i: number, a: A) => a is B): (fa: GeneratorL<A>) => GeneratorL<B>;
+export declare function filterWithIndex<A>(predicateWithIndex: (i: number, a: A) => boolean): (fa: GeneratorL<A>) => GeneratorL<A>;
+export declare const filterMapWithIndex: <A, B>(a: (i: number, a: A) => Op.Option<B>) => (b: GeneratorL<A>) => GeneratorL<B>;
+export declare function partitionWithIndex<A, B extends A>(refinementWithIndex: (i: number, a: A) => a is B): (fa: GeneratorL<A>) => S.Separated<GeneratorL<A>, GeneratorL<B>>;
+export declare function partitionWithIndex<A>(predicateWithIndex: (i: number, a: A) => boolean): (fa: GeneratorL<A>) => S.Separated<GeneratorL<A>, GeneratorL<A>>;
+export declare const partitionMapWithIndex: <A, B, C>(a: (i: number, a: A) => Ei.Either<B, C>) => (b: GeneratorL<A>) => S.Separated<GeneratorL<B>, GeneratorL<C>>;
+export declare const Foldable: Fo.Foldable1<URI>;
+export declare const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => (fa: GeneratorL<A>) => B;
+export declare const foldMap: <M>(M: Mono.Monoid<M>) => <A>(f: (a: A) => M) => (fa: GeneratorL<A>) => M;
+export declare const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: GeneratorL<A>) => B;
+export declare const FoldableWithIndex: FoWI.FoldableWithIndex1<URI, number>;
+export declare const reduceWithIndex: <A, B>(b: B, f: (i: number, b: B, a: A) => B) => (fa: GeneratorL<A>) => B;
+export declare const foldMapWithIndex: <M>(M: Mono.Monoid<M>) => <A>(f: (i: number, a: A) => M) => (fa: GeneratorL<A>) => M;
+export declare const reduceRightWithIndex: <A, B>(b: B, f: (i: number, a: A, b: B) => B) => (fa: GeneratorL<A>) => B;
+export declare function sequence<F extends URIS4>(F: Appli.Applicative4<F>): <S, R, E, A>(ta: GeneratorL<Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, GeneratorL<A>>;
+export declare function sequence<F extends URIS3>(F: Appli.Applicative3<F>): <R, E, A>(ta: GeneratorL<Kind3<F, R, E, A>>) => Kind3<F, R, E, GeneratorL<A>>;
+export declare function sequence<F extends URIS3, E>(F: Appli.Applicative3C<F, E>): <R, A>(ta: GeneratorL<Kind3<F, R, E, A>>) => Kind3<F, R, E, GeneratorL<A>>;
+export declare function sequence<F extends URIS2>(F: Appli.Applicative2<F>): <E, A>(ta: GeneratorL<Kind2<F, E, A>>) => Kind2<F, E, GeneratorL<A>>;
+export declare function sequence<F extends URIS2, E>(F: Appli.Applicative2C<F, E>): <A>(ta: GeneratorL<Kind2<F, E, A>>) => Kind2<F, E, GeneratorL<A>>;
+export declare function sequence<F extends URIS>(F: Appli.Applicative1<F>): <A>(ta: GeneratorL<Kind<F, A>>) => Kind<F, GeneratorL<A>>;
+export declare const Traversable: T.Traversable1<URI>;
+export declare function traverse<F extends URIS4>(F: Appli.Applicative4<F>): <A, S, R, E, B>(f: (a: A) => Kind4<F, S, R, E, B>) => (ta: GeneratorL<A>) => Kind4<F, S, R, E, GeneratorL<B>>;
+export declare function traverse<F extends URIS3>(F: Appli.Applicative3<F>): <A, R, E, B>(f: (a: A) => Kind3<F, R, E, B>) => (ta: GeneratorL<A>) => Kind3<F, R, E, GeneratorL<B>>;
+export declare function traverse<F extends URIS3, E>(F: Appli.Applicative3C<F, E>): <A, R, B>(f: (a: A) => Kind3<F, R, E, B>) => (ta: GeneratorL<A>) => Kind3<F, R, E, GeneratorL<B>>;
+export declare function traverse<F extends URIS2>(F: Appli.Applicative2<F>): <A, E, B>(f: (a: A) => Kind2<F, E, B>) => (ta: GeneratorL<A>) => Kind2<F, E, GeneratorL<B>>;
+export declare function traverse<F extends URIS2, E>(F: Appli.Applicative2C<F, E>): <A, B>(f: (a: A) => Kind2<F, E, B>) => (ta: GeneratorL<A>) => Kind2<F, E, GeneratorL<B>>;
+export declare function traverse<F extends URIS>(F: Appli.Applicative1<F>): <A, B>(f: (a: A) => Kind<F, B>) => (ta: GeneratorL<A>) => Kind<F, GeneratorL<B>>;
+export declare const TraversableWithIndex: TWI.TraversableWithIndex1<URI, number>;
+export declare function traverseWithIndex<F extends URIS4>(F: Appli.Applicative4<F>): <A, S, R, E, B>(f: (i: number, a: A) => Kind4<F, S, R, E, B>) => (ta: GeneratorL<A>) => Kind4<F, S, R, E, GeneratorL<B>>;
+export declare function traverseWithIndex<F extends URIS3>(F: Appli.Applicative3<F>): <A, R, E, B>(f: (i: number, a: A) => Kind3<F, R, E, B>) => (ta: GeneratorL<A>) => Kind3<F, R, E, GeneratorL<B>>;
+export declare function traverseWithIndex<F extends URIS3, E>(F: Appli.Applicative3C<F, E>): <A, R, B>(f: (i: number, a: A) => Kind3<F, R, E, B>) => (ta: GeneratorL<A>) => Kind3<F, R, E, GeneratorL<B>>;
+export declare function traverseWithIndex<F extends URIS2>(F: Appli.Applicative2<F>): <A, E, B>(f: (i: number, a: A) => Kind2<F, E, B>) => (ta: GeneratorL<A>) => Kind2<F, E, GeneratorL<B>>;
+export declare function traverseWithIndex<F extends URIS2, E>(F: Appli.Applicative2C<F, E>): <A, B>(f: (i: number, a: A) => Kind2<F, E, B>) => (ta: GeneratorL<A>) => Kind2<F, E, GeneratorL<B>>;
+export declare function traverseWithIndex<F extends URIS>(F: Appli.Applicative1<F>): <A, B>(f: (i: number, a: A) => Kind<F, B>) => (ta: GeneratorL<A>) => Kind<F, GeneratorL<B>>;
+export declare const Witherable: W.Witherable1<URI>;
+export declare function wilt<F extends URIS3>(F: Appli.Applicative3<F>): <A, R, E, B, C>(f: (a: A) => Kind3<F, R, E, Ei.Either<B, C>>) => (wa: GeneratorL<A>) => Kind3<F, R, E, S.Separated<GeneratorL<B>, GeneratorL<C>>>;
+export declare function wilt<F extends URIS3, E>(F: Appli.Applicative3C<F, E>): <A, R, B, C>(f: (a: A) => Kind3<F, R, E, Ei.Either<B, C>>) => (wa: GeneratorL<A>) => Kind3<F, R, E, S.Separated<GeneratorL<B>, GeneratorL<C>>>;
+export declare function wilt<F extends URIS2>(F: Appli.Applicative2<F>): <A, E, B, C>(f: (a: A) => Kind2<F, E, Ei.Either<B, C>>) => (wa: GeneratorL<A>) => Kind2<F, E, S.Separated<GeneratorL<B>, GeneratorL<C>>>;
+export declare function wilt<F extends URIS2, E>(F: Appli.Applicative2C<F, E>): <A, B, C>(f: (a: A) => Kind2<F, E, Ei.Either<B, C>>) => (wa: GeneratorL<A>) => Kind2<F, E, S.Separated<GeneratorL<B>, GeneratorL<C>>>;
+export declare function wilt<F extends URIS>(F: Appli.Applicative1<F>): <A, B, C>(f: (a: A) => Kind<F, Ei.Either<B, C>>) => (wa: GeneratorL<A>) => Kind<F, S.Separated<GeneratorL<B>, GeneratorL<C>>>;
+export declare function wither<F extends URIS3>(F: Appli.Applicative3<F>): <A, R, E, B>(f: (a: A) => Kind3<F, R, E, Op.Option<B>>) => (ta: GeneratorL<A>) => Kind3<F, R, E, GeneratorL<B>>;
+export declare function wither<F extends URIS3, E>(F: Appli.Applicative3C<F, E>): <A, R, B>(f: (a: A) => Kind3<F, R, E, Op.Option<B>>) => (ta: GeneratorL<A>) => Kind3<F, R, E, GeneratorL<B>>;
+export declare function wither<F extends URIS2>(F: Appli.Applicative2<F>): <A, E, B>(f: (a: A) => Kind2<F, E, Op.Option<B>>) => (ta: GeneratorL<A>) => Kind2<F, E, GeneratorL<B>>;
+export declare function wither<F extends URIS2, E>(F: Appli.Applicative2C<F, E>): <A, B>(f: (a: A) => Kind2<F, E, Op.Option<B>>) => (ta: GeneratorL<A>) => Kind2<F, E, GeneratorL<B>>;
+export declare function wither<F extends URIS>(F: Appli.Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Op.Option<B>>) => (ta: GeneratorL<A>) => Kind<F, GeneratorL<B>>;
+export declare const makeBy: <A>(f: (i: number) => A) => GeneratorL<A>;
+export declare const range: (start: number, end?: number) => GeneratorL<number>;
+export declare const replicate: <A>(a: A) => GeneratorL<A>;
+export declare const fromReadonlyArray: <A>(as: readonly A[]) => GeneratorL<A>;
+export declare const fromReadonlyRecord: <K extends string, A>(r: Readonly<Record<K, A>>) => GeneratorL<readonly [K, A]>;
+export declare const random: GeneratorL<number>;
+export declare const randomInt: (low: number, high: number) => GeneratorL<Int>;
+export declare const randomRange: (min: number, max: number) => GeneratorL<number>;
+export declare const randomBool: GeneratorL<boolean>;
+export declare const randomElem: <A>(as: RNEA.ReadonlyNonEmptyArray<A>) => GeneratorL<A>;
+export declare const prime: GeneratorL<number>;
+export declare const exp: GeneratorL<number>;
+export declare const fibonacci: GeneratorL<number>;
+export declare const flatten: <A>(mma: GeneratorL<GeneratorL<A>>) => GeneratorL<A>;
+export declare const prepend: <A>(a: A) => (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const append: <A>(a: A) => (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const takeLeft: (n: number) => <A>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const takeRight: (n: number) => <A>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare function takeLeftWhile<A, B extends A>(refinement: Refinement<A, B>): (ma: GeneratorL<A>) => GeneratorL<B>;
+export declare function takeLeftWhile<A>(predicate: Predicate<A>): (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const dropLeft: (n: number) => <A>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const dropRight: (n: number) => <A>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare function dropLeftWhile<A, B extends A>(refinement: Refinement<A, B>): (ma: GeneratorL<A>) => GeneratorL<B>;
+export declare function dropLeftWhile<A>(predicate: Predicate<A>): (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const scanLeft: <A, B>(b: B, f: (b: B, a: A) => B) => (ma: GeneratorL<A>) => GeneratorL<B>;
+export declare const scanRight: <A, B>(b: B, f: (a: A, b: B) => B) => (ma: GeneratorL<A>) => GeneratorL<B>;
+export declare function sieve<A>(f: (init: ReadonlyArray<A>, a: A) => boolean): (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const uniq: <A>(E: Eq.Eq<A>) => (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const sort: <B>(O: Or.Ord<B>) => <A extends B>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const sortBy: <B>(Os: readonly Or.Ord<B>[]) => <A extends B>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const reverse: <A>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const zipWith: <A, B, C>(mb: GeneratorL<B>, f: (a: A, b: B) => C) => (ma: GeneratorL<A>) => GeneratorL<C>;
+export declare const zip: <B>(mb: GeneratorL<B>) => <A>(ma: GeneratorL<A>) => GeneratorL<readonly [A, B]>;
+export declare const rights: <E, A>(ma: GeneratorL<Ei.Either<E, A>>) => GeneratorL<A>;
+export declare const lefts: <E, A>(ma: GeneratorL<Ei.Either<E, A>>) => GeneratorL<E>;
+export declare const prependAll: <A>(middle: A) => (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const intersperse: <A>(middle: A) => (ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const rotate: (n: number) => <A>(ma: GeneratorL<A>) => GeneratorL<A>;
+export declare const chop: <A, B>(f: (ma: GeneratorL<A>) => readonly [B, GeneratorL<A>]) => (ma: GeneratorL<A>) => GeneratorL<B>;
+export declare const chunksOf: (n: number) => <A>(ma: GeneratorL<A>) => GeneratorL<GeneratorL<A>>;
+export declare const matchLeft: <A, B>(onEmpty: Lazy<B>, onNonEmpty: (head: A, tail: GeneratorL<A>) => B) => (ma: GeneratorL<A>) => B;
+export declare const matchRight: <A, B>(onEmpty: Lazy<B>, onNonEmpty: (init: GeneratorL<A>, last: A) => B) => (ma: GeneratorL<A>) => B;
+export declare const toReadonlyArray: <A>(ma: GeneratorL<A>) => readonly A[];
+export declare const lookup: (i: number) => <A>(ma: GeneratorL<A>) => Op.Option<A>;
+export declare const head: <A>(ma: GeneratorL<A>) => Op.Option<A>;
+export declare const last: <A>(ma: GeneratorL<A>) => Op.Option<A>;
+export declare const tail: <A>(ma: GeneratorL<A>) => Op.Option<GeneratorL<A>>;
+export declare const init: <A>(ma: GeneratorL<A>) => Op.Option<GeneratorL<A>>;
+export interface Spanned<I, R> {
+    init: GeneratorL<I>;
+    rest: GeneratorL<R>;
+}
+export declare function spanLeft<A, B extends A>(refinement: Refinement<A, B>): (ma: GeneratorL<A>) => Spanned<B, A>;
+export declare function spanLeft<A>(predicate: Predicate<A>): (ma: GeneratorL<A>) => Spanned<A, A>;
+export declare const splitAt: (n: number) => <A>(ma: GeneratorL<A>) => readonly [GeneratorL<A>, GeneratorL<A>];
+export declare const unzip: <A, B>(mab: GeneratorL<readonly [A, B]>) => readonly [GeneratorL<A>, GeneratorL<B>];
+export declare const isEmpty: (ma: GeneratorL<unknown>) => boolean;
+export declare const isNonEmpty: Predicate<GeneratorL<unknown>>;
+export declare const size: (b: GeneratorL<unknown>) => number;
+export declare const isOutOfBound: (n: number) => (ma: GeneratorL<unknown>) => boolean;
+export declare function findFirst<A, B extends A>(refinement: Refinement<A, B>): (ma: GeneratorL<A>) => Op.Option<B>;
+export declare function findFirst<A>(predicate: Predicate<A>): (ma: GeneratorL<A>) => Op.Option<A>;
+export declare const findFirstMap: <A, B>(f: (a: A) => Op.Option<B>) => (ma: GeneratorL<A>) => Op.Option<B>;
+export declare const findFirstIndex: <A>(predicate: Predicate<A>) => (ma: GeneratorL<A>) => Op.Option<number>;
+export declare function findLast<A, B extends A>(refinement: Refinement<A, B>): (ma: GeneratorL<A>) => Op.Option<B>;
+export declare function findLast<A>(predicate: Predicate<A>): (ma: GeneratorL<A>) => Op.Option<A>;
+export declare const findLastMap: <A, B>(f: (a: A) => Op.Option<B>) => (ma: GeneratorL<A>) => Op.Option<B>;
+export declare const findLastIndex: <A>(predicate: Predicate<A>) => (ma: GeneratorL<A>) => Op.Option<number>;
+export declare const elem: <A>(Eq: Eq.Eq<A>) => (a: A) => (ma: GeneratorL<A>) => Op.Option<A>;
+export declare const insertAt: <A>(i: number, a: A) => (ma: GeneratorL<A>) => Op.Option<GeneratorL<A>>;
+export declare const modifyAt: <A>(i: number, f: (a: A) => A) => (ma: GeneratorL<A>) => Op.Option<GeneratorL<A>>;
+export declare const updateAt: <A>(i: number, a: A) => (ma: GeneratorL<A>) => Op.Option<GeneratorL<A>>;
+export declare const deleteAt: <A>(i: number) => (ma: GeneratorL<A>) => Op.Option<GeneratorL<A>>;