functype 0.8.35 → 0.8.37

package/lib/iterable/index.d.ts

@@ -1,22 +0,0 @@
-import { Functor, Type } from "../functor";
-import { Option } from "../option/Option";
-export type _Iterable_<A extends Type> = {
-    count(p: (x: A) => boolean): number;
-    find(p: (a: A) => boolean): Option<A>;
-    forEach(f: (a: A) => void): void;
-    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;
-    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;
-    get head(): 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>): _Iterable_<B>;
-    get size(): number;
-    toArray(): readonly A[];
-} & Functor<A>;
-export { Seq } from "./Seq";

package/lib/list/List.d.ts

@@ -1,26 +0,0 @@
-import { Collection } from "../collections";
-import { _Iterable_, Seq } from "../iterable";
-import { Option } from "../option/Option";
-import { Set } from "../set/Set";
-import { Typeable } from "../typeable/Typeable";
-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;
-    toValue: () => {
-        _tag: string;
-        value: A[];
-    };
-} & Seq<A> & Typeable<"List">;
-type InternalList<A> = List<A> & ArrayLike<A> & _Iterable_<A> & Collection<A>;
-export declare const List: <A>(values?: Iterable<A> | _Iterable_<A>) => List<A>;
-export declare const TestList: <A>(values?: Iterable<A> | _Iterable_<A>) => InternalList<A>;
-export {};

package/lib/map/Map.d.ts

@@ -1,17 +0,0 @@
-import { Collection } from "../collections";
-import { Traversable } from "../index";
-import { _Iterable_ } from "../iterable";
-import { Option } from "../option/Option";
-import { Tuple } from "../tuple/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 const Map: <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null) => Map<K, V>;
-export {};

package/lib/map/shim.d.ts

@@ -1,2 +0,0 @@
-export type IESMap<K, V> = Map<K, V>;
-export declare const ESMap: MapConstructor;

package/lib/option/Option.d.ts

@@ -1,30 +0,0 @@
-import { Functor, Type } from "../functor";
-import { Either, List, Traversable } from "../index";
-import { Typeable } from "../typeable/Typeable";
-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>;
-    filter(predicate: (value: T) => boolean): Option<T>;
-    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(): List<T>;
-    contains(value: T): boolean;
-    size: number;
-    toEither<E>(left: E): Either<E, T>;
-    toString(): string;
-    toValue(): {
-        _tag: "Some" | "None";
-        value: T;
-    };
-} & (Traversable<T> & Functor<T> & Typeable<"Some" | "None">);
-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>;

package/lib/serializable/Serializable.d.ts

@@ -1,15 +0,0 @@
-export type SerializableTypes = "json" | "yaml";
-type SerializationMethods<T> = {
-    json: {
-        toJSON(): string;
-        fromJSON(json: string): T;
-    };
-    yaml: {
-        toYAML(): string;
-        fromYAML(yaml: string): T;
-    };
-};
-export type Serializable<STypes extends SerializableTypes[], T> = T & (STypes extends [] ? NonNullable<unknown> : STypes extends [infer First, ...infer Rest] ? First extends keyof SerializationMethods<T> ? SerializationMethods<T>[First] & Serializable<Rest extends SerializableTypes[] ? Rest : [], T> : never : never);
-export type SupportedSerializationTypes<T> = T extends Serializable<infer Types, never> ? Types : never;
-export declare function createSerializable<STypes extends SerializableTypes[], T>(obj: T, serializationMethods: Pick<SerializationMethods<T>, STypes[number]>): Serializable<STypes, T>;
-export {};

package/lib/set/Set.d.ts

@@ -1,15 +0,0 @@
-import { Collection } from "../collections";
-import { _Iterable_ } from "../iterable";
-import { List } from "../list/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/shim.d.ts

@@ -1,2 +0,0 @@
-export type IESSet<T> = Set<T>;
-export declare const ESSet: SetConstructor;

package/lib/try/Try.d.ts

@@ -1,18 +0,0 @@
-import { Either } from "../either/Either";
-import { Typeable } from "../typeable/Typeable";
-export type Try<T> = {
-    readonly _tag: "Success" | "Failure";
-    readonly value: T | undefined;
-    readonly error: Error | undefined;
-    isSuccess: () => boolean;
-    isFailure: () => boolean;
-    get: () => T;
-    getOrElse: (defaultValue: T) => T;
-    orElse: (alternative: Try<T>) => Try<T>;
-    orThrow: (error: Error) => T;
-    toEither: () => Either<Error, T>;
-    map: <U>(f: (value: T) => U) => Try<U>;
-    flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
-    toString: () => string;
-} & Typeable<"Success" | "Failure">;
-export declare const Try: <T>(f: () => T) => Try<T>;

package/lib/tuple/Tuple.d.ts

@@ -1,9 +0,0 @@
-import { ArrayFunctor, ArrayType } from "../functor";
-export 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>;
-    toArray(): T;
-    [Symbol.iterator](): Iterator<T[number]>;
-} & ArrayFunctor<T>;
-export declare const Tuple: <T extends ArrayType>(values: T) => Tuple<T>;

package/lib/typeable/Typeable.d.ts

@@ -1,4 +0,0 @@
-export declare function Typeable(type: string): {
-    readonly _tag: string;
-};
-export type Typeable<T extends string> = ReturnType<typeof Typeable>;

package/lib/util/index.d.ts

@@ -1,3 +0,0 @@
-import { Either } from "../either/Either";
-import { ParseError } from "../error/ParseError";
-export declare const parseNumber: (input: string) => Either<ParseError, number>;

package/lib/util/isIterable.d.ts

@@ -1 +0,0 @@
-export declare const isIterable: <T>(value: unknown) => value is Iterable<T>;