functype 0.4.2 → 0.8.0

package/dist/tuple/Tuple.d.ts

@@ -1,20 +1,12 @@
-import { ArrayType, _ArrayFunctor_ } from '../functor/index.js';
+import { ArrayType, ArrayFunctor } from '../functor/index.js';
 
-type _Tuple_<T extends ArrayType> = _ArrayFunctor_<T> & {
-    get(index: number): T[number];
-    getAs<U>(index: number, f?: (item: T) => boolean): U;
-    map<U extends any[]>(f: (value: T) => U): _Tuple_<U>;
-    flatMap<U extends any[]>(f: (value: T) => _Tuple_<U>): _Tuple_<U>;
-    toArray(): T;
-};
-declare class Tuple<T extends ArrayType> implements _Tuple_<T> {
-    private readonly values;
-    constructor(values: T);
+type Tuple<T extends ArrayType> = {
+    get<K extends number>(index: K): T[K];
     map<U extends ArrayType>(f: (value: T) => U): Tuple<U>;
     flatMap<U extends ArrayType>(f: (value: T) => Tuple<U>): Tuple<U>;
-    get(index: number): T[number];
-    getAs<U>(index: number, f?: (item: T) => boolean): U;
     toArray(): T;
-}
+    [Symbol.iterator](): Iterator<T[number]>;
+} & ArrayFunctor<T>;
+declare const Tuple: <T extends ArrayType>(values: T) => Tuple<T>;
 
-export { Tuple, type _Tuple_ };
+export { Tuple };

package/dist/tuple/Tuple.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkV5UFW2E4js = require('../chunk-V5UFW2E4.js');require('../chunk-O2XFH626.js');exports.Tuple = _chunkV5UFW2E4js.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkOXLZ6UIZjs = require('../chunk-OXLZ6UIZ.js');exports.Tuple = _chunkOXLZ6UIZjs.a;

package/dist/tuple/Tuple.mjs

@@ -1 +1 @@
-import{a}from"../chunk-2XH6TPQK.mjs";import"../chunk-JR557W27.mjs";export{a as Tuple};
+import{a}from"../chunk-2I2NKDFN.mjs";export{a as Tuple};

package/dist/tuple/index.d.mts

@@ -1,6 +1,5 @@
 import { ArrayType } from '../functor/index.mjs';
 import { Tuple } from './Tuple.mjs';
-export { _Tuple_ } from './Tuple.mjs';
 
 declare const t: <T extends ArrayType>(values: T) => Tuple<T>;
 declare const tuple: <T extends ArrayType>(values: T) => Tuple<T>;

package/dist/tuple/index.d.ts

@@ -1,6 +1,5 @@
 import { ArrayType } from '../functor/index.js';
 import { Tuple } from './Tuple.js';
-export { _Tuple_ } from './Tuple.js';
 
 declare const t: <T extends ArrayType>(values: T) => Tuple<T>;
 declare const tuple: <T extends ArrayType>(values: T) => Tuple<T>;

package/dist/tuple/index.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkSKJIJETAjs = require('../chunk-SKJIJETA.js');var _chunkV5UFW2E4js = require('../chunk-V5UFW2E4.js');require('../chunk-O2XFH626.js');exports.Tuple = _chunkV5UFW2E4js.a; exports.t = _chunkSKJIJETAjs.a; exports.tuple = _chunkSKJIJETAjs.b;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkE3BAZBU2js = require('../chunk-E3BAZBU2.js');var _chunkOXLZ6UIZjs = require('../chunk-OXLZ6UIZ.js');exports.Tuple = _chunkOXLZ6UIZjs.a; exports.t = _chunkE3BAZBU2js.a; exports.tuple = _chunkE3BAZBU2js.b;

package/dist/tuple/index.mjs

@@ -1 +1 @@
-import{a as b,b as c}from"../chunk-HOO2EPER.mjs";import{a}from"../chunk-2XH6TPQK.mjs";import"../chunk-JR557W27.mjs";export{a as Tuple,b as t,c as tuple};
+import{a as b,b as c}from"../chunk-4AEODSGH.mjs";import{a}from"../chunk-2I2NKDFN.mjs";export{a as Tuple,b as t,c as tuple};

package/dist/util/index.d.mts

@@ -1,5 +1,5 @@
+import { E as Either } from '../index-BB5a793T.mjs';
 import { ParseError } from '../error/ParseError.mjs';
-import { E as Either } from '../index-UMWeD2QH.mjs';
 import '../functor/index.mjs';
 import '../tuple/Tuple.mjs';
 import '../tuple/index.mjs';

package/dist/util/index.d.ts

@@ -1,5 +1,5 @@
+import { E as Either } from '../index-DyWcaZaG.js';
 import { ParseError } from '../error/ParseError.js';
-import { E as Either } from '../index-Dbjb4MUT.js';
 import '../functor/index.js';
 import '../tuple/Tuple.js';
 import '../tuple/index.js';

package/dist/util/index.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBYDMB2VVjs = require('../chunk-BYDMB2VV.js');require('../chunk-3EH27NX2.js');var _chunkZTL76QDLjs = require('../chunk-ZTL76QDL.js');require('../chunk-RM3O3IPT.js');require('../chunk-XVHCBGUW.js');require('../chunk-3APFKSCC.js');require('../chunk-BNNK42JC.js');require('../chunk-3VJERXBP.js');require('../chunk-O2XFH626.js');var n=s=>{let r=parseInt(s,10);return isNaN(r)?_chunkBYDMB2VVjs.a.call(void 0, new (0, _chunkZTL76QDLjs.a)(`${r}`)):_chunkBYDMB2VVjs.b.call(void 0, r)};exports.parseNumber = n;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk4PGXHDASjs = require('../chunk-4PGXHDAS.js');require('../chunk-TVCOFH5I.js');require('../chunk-KWPKGISB.js');require('../chunk-3VJERXBP.js');var _chunkE6RS47F7js = require('../chunk-E6RS47F7.js');require('../chunk-WDHUQRFT.js');require('../chunk-BNNK42JC.js');var n=s=>{let r=parseInt(s,10);return isNaN(r)?_chunk4PGXHDASjs.a.call(void 0, _chunkE6RS47F7js.a.call(void 0, `${r}`)):_chunk4PGXHDASjs.b.call(void 0, r)};exports.parseNumber = n;

package/dist/util/index.mjs

@@ -1 +1 @@
-import{a as e,b as t}from"../chunk-HC3O3O2B.mjs";import"../chunk-GTO34VMN.mjs";import{a as o}from"../chunk-CFYIJKWF.mjs";import"../chunk-KY3WKBLM.mjs";import"../chunk-74TKYQJS.mjs";import"../chunk-TYHKMGLC.mjs";import"../chunk-RRAIFS3D.mjs";import"../chunk-HA5XD5KC.mjs";import"../chunk-JR557W27.mjs";var n=s=>{let r=parseInt(s,10);return isNaN(r)?e(new o(`${r}`)):t(r)};export{n as parseNumber};
+import{a as e,b as t}from"../chunk-3Y43FJKZ.mjs";import"../chunk-HJAAA6CD.mjs";import"../chunk-GPS3OL5F.mjs";import"../chunk-HA5XD5KC.mjs";import{a as o}from"../chunk-VK5GL6NM.mjs";import"../chunk-FMHIRYL5.mjs";import"../chunk-RRAIFS3D.mjs";var n=s=>{let r=parseInt(s,10);return isNaN(r)?e(o(`${r}`)):t(r)};export{n as parseNumber};

package/dist/util/isIterable.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBNNK42JCjs = require('../chunk-BNNK42JC.js');require('../chunk-O2XFH626.js');exports.isIterable = _chunkBNNK42JCjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkBNNK42JCjs = require('../chunk-BNNK42JC.js');exports.isIterable = _chunkBNNK42JCjs.a;

package/dist/util/isIterable.mjs

@@ -1 +1 @@
-import{a}from"../chunk-RRAIFS3D.mjs";import"../chunk-JR557W27.mjs";export{a as isIterable};
+import{a}from"../chunk-RRAIFS3D.mjs";export{a as isIterable};

package/lib/collections/index.d.ts

@@ -1,8 +1,8 @@
-import { _Set_ } from "../set";
-import { _List_ } from "../list";
-export type IConverters<A> = {
-    toList(): _List_<A>;
-    toSet(): _Set_<A>;
+import { List } from "../list";
+import { Set } from "../set";
+export type Converters<A> = {
+    toList(): List<A>;
+    toSet(): Set<A>;
     toString(): string;
 };
-export type _Collection<A> = IConverters<A>;
+export type Collection<A> = Converters<A>;

package/lib/either/Either.d.ts

@@ -1,32 +1,32 @@
-import { _Option_ } from "../option";
+import { Functor, Type } from "../functor";
 import { List } from "../list";
-import { _Functor_ } from "../functor";
-export type Either<L, R> = {
+import { Option } from "../option";
+import { Typeable } from "../index";
+export type Either<L extends Type, R extends Type> = {
+    readonly _tag: "Left" | "Right";
     value: L | R;
-    isLeft(): boolean;
-    isRight(): boolean;
-    map<U>(f: (value: R) => U): Either<L, U>;
-    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): _Option_<R>;
-    toList(): List<R>;
-} & _Functor_<R>;
-export declare class Right<L, R> implements Either<L, R> {
+    isLeft: () => boolean;
+    isRight: () => boolean;
+    map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
+    flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
+    toOption: () => Option<R>;
+    toList: () => List<R>;
+    valueOf: () => {
+        _tag: "Left" | "Right";
+        value: L | R;
+    };
+    toString: () => string;
+} & Functor<R> & Typeable;
+export declare const Right: <L, R>(value: R) => Either<L, R>;
+export declare const Left: <L, R>(value: L) => Either<L, R>;
+export declare const isRight: <L, R>(either: Either<L, R>) => either is Either<L, R> & {
     value: R;
-    constructor(value: R);
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(f: (value: R) => U): Either<L, U>;
-    flatMap<U>(f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): _Option_<R>;
-    toList(): List<R>;
-}
-export declare class Left<L, R> implements Either<L, R> {
+};
+export declare const isLeft: <L, R>(either: Either<L, R>) => either is Either<L, R> & {
     value: L;
-    constructor(value: L);
-    isLeft(): this is Left<L, R>;
-    isRight(): this is Right<L, R>;
-    map<U>(_f: (value: R) => U): Either<L, U>;
-    flatMap<U>(_f: (value: R) => Either<L, U>): Either<L, U>;
-    toOption(): _Option_<R>;
-    toList(): List<R>;
-}
+};
+export declare const tryCatch: <L, R>(f: () => R, onError: (error: unknown) => L) => Either<L, R>;
+export declare const match: <L, R, U>(either: Either<L, R>, patterns: {
+    Left: (value: L) => U;
+    Right: (value: R) => U;
+}) => U;

package/lib/either/index.d.ts

@@ -1,4 +1,4 @@
 import { Either, Left, Right } from "./Either";
 export declare const left: <L, R>(value: L) => Either<L, R>;
 export declare const right: <L, R>(value: R) => Either<L, R>;
-export { Left, Right, Either };
+export { Either, Left, Right };

package/lib/error/ParseError.d.ts

@@ -1,2 +1,6 @@
-export declare class ParseError extends Error {
-}
+export declare const ParseError: (message?: string) => Error & {
+    name: "ParseError";
+};
+export type ParseError = Error & {
+    name: "ParseError";
+};

package/lib/functor/index.d.ts

@@ -1,15 +1,15 @@
-export type SingleType = any;
+export type SingleType = unknown;
 export type ArrayType = SingleType[];
 export type Type = SingleType | ArrayType;
-export type _AbstractFunctor_<A extends Type> = {
-    map(f: (value: A) => Type): _AbstractFunctor_<Type>;
-    flatMap(f: (value: A) => _AbstractFunctor_<Type>): _AbstractFunctor_<Type>;
+export type AbstractFunctor<A extends Type> = {
+    map(f: (value: A) => Type): AbstractFunctor<Type>;
+    flatMap(f: (value: A) => AbstractFunctor<Type>): AbstractFunctor<Type>;
 };
-export type _Functor_<A extends Type> = _AbstractFunctor_<A> & {
-    map<B extends Type>(f: (value: A) => B): _Functor_<B>;
-    flatMap<B extends Type>(f: (value: A) => _Functor_<B>): _Functor_<B>;
+export type Functor<A extends Type> = AbstractFunctor<A> & {
+    map<B extends Type>(f: (value: A) => B): Functor<B>;
+    flatMap<B extends Type>(f: (value: A) => Functor<B>): Functor<B>;
 };
-export type _ArrayFunctor_<A extends ArrayType> = _AbstractFunctor_<A> & {
-    map<U extends ArrayType>(f: (value: A) => U): _ArrayFunctor_<U>;
-    flatMap<U extends ArrayType>(f: (value: A) => _ArrayFunctor_<U>): _ArrayFunctor_<U>;
+export type ArrayFunctor<A extends ArrayType> = AbstractFunctor<A> & {
+    map<U extends ArrayType>(f: (value: A) => U): ArrayFunctor<U>;
+    flatMap<U extends ArrayType>(f: (value: A) => ArrayFunctor<U>): ArrayFunctor<U>;
 };

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { _Functor_, Type } from "./functor";
-export type _Traversable_<A extends Type> = _Functor_<A> & {
+import { Functor, Type } from "./functor";
+export type Traversable<A extends Type> = Functor<A> & {
     get size(): number;
     get isEmpty(): boolean;
     contains(value: A): boolean;
@@ -8,12 +8,15 @@ export type _Traversable_<A extends Type> = _Functor_<A> & {
     foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
     foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
 };
+export * from "./either";
 export * from "./functor";
 export * from "./iterable";
 export * from "./list";
 export * from "./map";
 export * from "./option";
-export * from "./either";
 export * from "./set";
-export * from "./tuple";
 export * from "./try";
+export * from "./tuple";
+export type Typeable = {
+    _tag: Type;
+};

package/lib/iterable/Seq.d.ts

@@ -1,25 +1,28 @@
+import { Option } from "../option";
 import { _Iterable_ } from "./index";
-import { _Option_ } from "../option";
-export declare class Seq<A> implements _Iterable_<A> {
-    protected readonly values: Iterable<A>;
-    constructor(values?: Iterable<A> | _Iterable_<A>);
-    readonly [n: number]: A;
-    get length(): number;
-    map<B>(f: (a: A) => B): _Iterable_<B>;
-    flatMap<B>(f: (a: A) => _Iterable_<B>): _Iterable_<B>;
-    forEach(f: (a: A) => void): void;
-    count(p: (x: A) => boolean): number;
-    exists(p: (a: A) => boolean): Boolean;
-    filter(p: (a: A) => boolean): _Iterable_<A>;
-    filterNot(p: (a: A) => boolean): _Iterable_<A>;
-    find(p: (a: A) => boolean): _Option_<A>;
-    get head(): A;
-    get headOption(): _Option_<A>;
-    get isEmpty(): boolean;
-    get size(): number;
-    toArray(): A[];
-    reduce(f: (prev: A, curr: A) => A): A;
-    reduceRight(f: (prev: A, curr: A) => A): A;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-}
+export type Seq<A> = {
+    readonly length: number;
+    readonly [Symbol.iterator]: () => Iterator<A>;
+    map: <B>(f: (a: A) => B) => Seq<B>;
+    flatMap: <B>(f: (a: A) => _Iterable_<B>) => Seq<B>;
+    forEach: (f: (a: A) => void) => void;
+    count: (p: (x: A) => boolean) => number;
+    exists: (p: (a: A) => boolean) => boolean;
+    filter: (p: (a: A) => boolean) => Seq<A>;
+    filterNot: (p: (a: A) => boolean) => Seq<A>;
+    find: (p: (a: A) => boolean) => Option<A>;
+    readonly head: A;
+    readonly headOption: Option<A>;
+    readonly isEmpty: boolean;
+    readonly size: number;
+    toArray: () => A[];
+    reduce: (f: (prev: A, curr: A) => A) => A;
+    reduceRight: (f: (prev: A, curr: A) => A) => A;
+    foldLeft: <B>(z: B) => (op: (b: B, a: A) => B) => B;
+    foldRight: <B>(z: B) => (op: (a: A, b: B) => B) => B;
+    valueOf: () => {
+        values: A[];
+    };
+} & _Iterable_<A>;
+export declare const createSeq: <A>(values?: Iterable<A> | _Iterable_<A>) => Seq<A>;
+export declare const Seq: <A>(values?: Iterable<A> | _Iterable_<A>) => Seq<A>;

package/lib/iterable/index.d.ts

@@ -1,10 +1,10 @@
-import { _Functor_, Type } from "../functor";
-import { _Option_ } from "../option";
+import { Functor, Type } from "../functor";
+import { Option } from "../option";
 export type _Iterable_<A extends Type> = {
     count(p: (x: A) => boolean): number;
-    find(p: (a: A) => boolean): _Option_<A>;
+    find(p: (a: A) => boolean): Option<A>;
     forEach(f: (a: A) => void): void;
-    exists(p: (a: A) => boolean): Boolean;
+    exists(p: (a: A) => boolean): boolean;
     filter(p: (a: A) => boolean): _Iterable_<A>;
     filterNot(p: (a: A) => boolean): _Iterable_<A>;
     reduce(f: (b: A, a: A) => A): A;
@@ -12,11 +12,11 @@ export type _Iterable_<A extends Type> = {
     foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
     foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
     get head(): A;
-    get headOption(): _Option_<A>;
+    get headOption(): Option<A>;
     get isEmpty(): boolean;
     map<B extends Type>(f: (a: A) => B): _Iterable_<B>;
-    flatMap<B extends Type>(f: (a: A) => _Iterable_<B>): _Iterable_<B>;
+    flatMap<B extends Type>(f: (a: A) => _Iterable_<B> | Iterable<B>): _Iterable_<B>;
     get size(): number;
     toArray(): readonly A[];
-} & _Functor_<A>;
+} & Functor<A>;
 export { Seq } from "./Seq";

package/lib/list/List.d.ts

@@ -1,23 +1,21 @@
+import { Collection } from "../collections";
 import { _Iterable_ } from "../iterable";
-import { Seq } from "../iterable";
-import { _Collection } from "../collections";
+import { Option } from "../option";
 import { Set } from "../set";
-import { _Option_ } from "../option";
-export interface _List_<T> extends _Iterable_<T>, ArrayLike<T> {
-    add(item: T): _List_<T>;
-}
-export declare class List<A> extends Seq<A> implements _List_<A>, _Collection<A> {
-    constructor(values?: Iterable<A> | _Iterable_<A>);
-    readonly [n: number]: A;
-    map<B>(f: (a: A) => B): List<B>;
-    flatMap<B>(f: (a: A) => _Iterable_<B>): List<B>;
-    remove(value: A): List<A>;
-    contains(value: A): boolean;
-    add(item: A): List<A>;
-    removeAt(index: number): List<A>;
-    get(index: number): _Option_<A>;
-    concat(other: List<A>): List<A>;
-    toList(): _List_<A>;
-    toSet(): Set<A>;
-    toString(): string;
-}
+export type List<A> = {
+    add: (item: A) => List<A>;
+    map: <B>(f: (a: A) => B) => List<B>;
+    flatMap: <B>(f: (a: A) => _Iterable_<B>) => List<B>;
+    remove: (value: A) => List<A>;
+    contains: (value: A) => boolean;
+    removeAt: (index: number) => List<A>;
+    get: (index: number) => Option<A>;
+    concat: (other: List<A>) => List<A>;
+    toList: () => List<A>;
+    toSet: () => Set<A>;
+    toString: () => string;
+    valueOf: () => {
+        values: A[];
+    };
+} & ArrayLike<A> & _Iterable_<A> & Collection<A>;
+export declare const List: <A>(values?: Iterable<A> | _Iterable_<A>) => List<A>;

package/lib/list/index.d.ts

@@ -1,3 +1,4 @@
-import { List, _List_ } from "./List";
-declare const list: <T extends unknown>(items: T[] | undefined) => List<T>;
-export { list, List, _List_ };
+import { Type } from "../functor";
+import { List } from "./List";
+declare const list: <T extends Type>(items: T[] | undefined) => List<T>;
+export { list, List };

package/lib/map/Map.d.ts

@@ -1,37 +1,16 @@
-import { _Tuple_, Tuple } from "../tuple";
-import { _Set_ } from "../set";
-import { _Option_ } from "../option";
-import { _List_ } from "../list";
-import { _Traversable_ } from "../index";
-import { _Collection } from "../collections";
-type SafeTraversable<K, V> = Omit<_Traversable_<_Tuple_<[K, V]>>, "map" | "flatMap">;
-export type _Map_<K, V> = {
-    map<U>(f: (value: any) => U): _Map_<K, U>;
-    flatMap<U>(f: (value: any) => _Map_<K, U>): _Map_<K, U>;
-    get(key: K): _Option_<V>;
+import { Collection } from "../collections";
+import { _Iterable_, Traversable } from "../index";
+import { Option } from "../option";
+import { Tuple } from "../tuple";
+type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, "map" | "flatMap">;
+export type Map<K, V> = {
+    add(item: Tuple<[K, V]>): Map<K, V>;
+    remove(value: K): Map<K, V>;
+    map<U>(f: (value: V) => U): Map<K, U>;
+    flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => _Iterable_<[K2, V2]>): Map<K2, V2>;
+    get(key: K): Option<V>;
     getOrElse(key: K, defaultValue: V): V;
-    orElse(key: K, alternative: _Option_<V>): _Option_<V>;
-} & SafeTraversable<K, V> & _Collection<_Tuple_<[K, V]>>;
-export declare class Map<K, V> implements _Map_<K, V> {
-    private values;
-    private get entries();
-    constructor(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null);
-    add(item: _Tuple_<[K, V]>): Map<K, V>;
-    remove(value: _Tuple_<[K, V]>): Map<K, V>;
-    contains(value: _Tuple_<[K, V]>): boolean;
-    get size(): number;
-    map<U>(f: (value: V) => U): _Map_<K, U>;
-    flatMap<U>(f: (value: V) => _Map_<K, U>): _Map_<K, U>;
-    reduce(f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]>;
-    reduceRight(f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]>;
-    foldLeft<B>(z: B): (op: (b: B, a: _Tuple_<[K, V]>) => B) => B;
-    foldRight<B>(z: B): (op: (a: _Tuple_<[K, V]>, b: B) => B) => B;
-    get(key: K): _Option_<V>;
-    getOrElse(key: K, defaultValue: V): V;
-    get isEmpty(): boolean;
-    orElse(key: K, alternative: _Option_<V>): _Option_<V>;
-    toList(): _List_<Tuple<[K, V]>>;
-    toSet(): _Set_<Tuple<[K, V]>>;
-    toString(): string;
-}
+    orElse(key: K, alternative: Option<V>): Option<V>;
+} & SafeTraversable<K, V> & Collection<Tuple<[K, V]>>;
+export declare const Map: <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map<K, V>;
 export {};

package/lib/map/index.d.ts

@@ -1 +1 @@
-export { Map, _Map_ } from "./Map";
+export { Map } from "./Map";

package/lib/option/Option.d.ts

@@ -1,44 +1,32 @@
-import { _Functor_, Type } from "../functor";
-import { _Traversable_ } from "../index";
+import { Functor, Type } from "../functor";
+import { Traversable, Typeable } from "../index";
 import { _Iterable_ } from "../iterable";
-export type _Option_<T extends Type> = {
+export type Option<T extends Type> = {
+    readonly _tag: "Some" | "None";
+    readonly value: T | undefined;
+    isEmpty: boolean;
     get(): T;
     getOrElse(defaultValue: T): T;
-    orElse(alternative: _Option_<T>): _Option_<T>;
-    map<U extends Type>(f: (value: T) => U): _Option_<U>;
-    flatMap<U extends Type>(f: (value: T) => _Option_<U>): _Option_<U>;
+    orElse(alternative: Option<T>): Option<T>;
+    map<U extends Type>(f: (value: T) => U): Option<U>;
+    flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
+    reduce<U>(f: (acc: U, value: T) => U): U;
+    reduceRight<U>(f: (acc: U, value: T) => U): U;
+    foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B;
+    foldRight<B>(z: B): (op: (a: T, b: B) => B) => B;
     toList(): _Iterable_<T>;
-    valueOf(): Object;
-} & _Traversable_<T> & _Functor_<T>;
-export declare class Some<A extends Type> implements _Option_<A> {
-    private value;
-    constructor(value: A);
-    get isEmpty(): boolean;
-    get(): A;
-    getOrElse(defaultValue: A): A;
-    orElse(alternative: _Option_<A>): _Option_<A>;
-    map<U extends Type>(f: (value: A) => U): _Option_<U>;
-    flatMap<U extends Type>(f: (value: A) => _Option_<U>): _Option_<U>;
-    reduce<U>(f: (acc: U, value: A) => U): U;
-    reduceRight<U>(f: (acc: U, value: A) => U): U;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-    toList(): _Iterable_<A>;
-    contains(value: A): boolean;
-    get size(): number;
-}
-export declare class None<A extends Type> implements _Option_<A> {
-    get isEmpty(): boolean;
-    get(): A;
-    getOrElse(defaultValue: A): A;
-    orElse(alternative: _Option_<A>): _Option_<A>;
-    map<U extends Type>(f: (value: A) => U): _Option_<U>;
-    flatMap<U extends Type>(f: (value: A) => _Option_<U>): _Option_<U>;
-    reduce(f: (acc: A, value: A) => A): A;
-    reduceRight(f: (b: A, a: A) => A): A;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-    toList(): _Iterable_<A>;
-    contains(value: A): boolean;
-    get size(): number;
-}
+    contains(value: T): boolean;
+    size: number;
+    valueOf(): {
+        _tag: "Some" | "None";
+        value?: T;
+    };
+    toString(): string;
+} & Traversable<T> & Functor<T> & Typeable;
+export declare const Some: <T extends Type>(value: T) => Option<T>;
+export declare const None: <T extends Type>() => Option<T>;
+export declare const Option: <T extends Type>(value: T | null | undefined) => Option<T>;
+export declare const match: <T extends Type, U>(option: Option<T>, patterns: {
+    Some: (value: T) => U;
+    None: () => U;
+}) => U;

package/lib/option/index.d.ts

@@ -1,5 +1,6 @@
-import { None, _Option_, Some } from "./Option";
-export declare const option: <T extends unknown>(value?: T) => _Option_<T>;
-export declare const some: <T extends unknown>(value: T) => _Option_<T>;
-export declare const none: <T extends unknown>() => _Option_<T>;
-export { _Option_, Some, None };
+import { Type } from "../functor";
+import { None, Option, Some } from "./Option";
+export declare const option: <T extends Type>(value?: T) => Option<T>;
+export declare const some: <T extends Type>(value: T) => Option<T>;
+export declare const none: <T extends Type>() => Option<T>;
+export { None, Option, Some };

package/lib/set/Set.d.ts

@@ -1,18 +1,15 @@
-import { _Iterable_, Seq } from "../iterable";
-import { _List_ } from "../list";
-import { _Collection } from "../collections";
-export type _Set_<T> = {
-    has(value: T): boolean;
-} & _Iterable_<T> & _Collection<T>;
-export declare class Set<A> extends Seq<A> implements _Set_<A> {
-    constructor(iterable?: Iterable<A> | _Iterable_<A>);
-    add(value: A): Set<A>;
-    remove(value: A): Set<A>;
-    contains(value: A): boolean;
-    has(value: A): boolean;
-    map<B>(f: (a: A) => B): Set<B>;
-    flatMap<B>(f: (a: A) => _Iterable_<B>): Set<B>;
-    toList(): _List_<A>;
-    toSet(): _Set_<A>;
-    toString(): string;
-}
+import { Collection } from "../collections";
+import { _Iterable_ } from "../iterable";
+import { List } from "../list";
+export type Set<A> = {
+    add: (value: A) => Set<A>;
+    remove: (value: A) => Set<A>;
+    contains: (value: A) => boolean;
+    has: (value: A) => boolean;
+    map: <B>(f: (a: A) => B) => Set<B>;
+    flatMap: <B>(f: (a: A) => _Iterable_<B>) => Set<B>;
+    toList: () => List<A>;
+    toSet: () => Set<A>;
+    toString: () => string;
+} & _Iterable_<A> & Collection<A>;
+export declare const Set: <A>(iterable?: Iterable<A> | _Iterable_<A>) => Set<A>;

package/lib/set/index.d.ts

@@ -1 +1 @@
-export { Set, _Set_ } from "./Set";
+export { Set } from "./Set";