declarations

// Type definitions for scalike API // Project: https://github.com/ryoppy/scalike-typescript // Definitions by: ryoppy <https://github.com/ryoppy> // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped declare namespace scalike { export interface Either<A, B> { value: A | B; isLeft: boolean; isRight: boolean; left(): LeftProjection<A, B>; right(): RightProjection<A, B>; fold<X>(fa: (a: A) => X, fb: (b: B) => X): X; swap(): Either<B, A>; } export function Right<A, B>(b: B): Either<A, B>; export function Left<A, B>(a: A): Either<A, B>; export class LeftProjection<A, B> { private self; constructor(self: Either<A, B>); toString(): string; get(): A; foreach(f: (a: A) => void): void; getOrElse<X extends A>(x: X): A; forall(f: (a: A) => boolean): boolean; exists(f: (a: A) => boolean): boolean; filter(f: (a: A) => boolean): Optional<Either<A, B>>; map<X>(f: (a: A) => X): Either<X | A, B>; flatMap<X>(f: (a: A) => Either<X, B>): Either<X | A, B>; toOptional(): Optional<A>; } export class RightProjection<A, B> { private self; constructor(self: Either<A, B>); toString(): string; get(): B; foreach(f: (b: B) => void): void; getOrElse<X extends B>(x: X): B; forall(f: (b: B) => boolean): boolean; exists(f: (b: B) => boolean): boolean; filter(f: (b: B) => boolean): Optional<Either<A, B>>; map<X>(f: (b: B) => X): Either<A, X | B>; flatMap<X>(f: (a: B) => Either<A, X>): Either<A, X | B>; toOptional(): Optional; } export interface Optional<A> { isEmpty: boolean; nonEmpty: boolean; get(): A; getOrElse(a: B): A; map(f: (a: A) => B): Optional; fold(ifEmpty: B, f: (a: A) => B): B; flatten(): Optional<A>; filter(f: (a: A) => boolean): Optional<A>; contains(b: B): boolean; exists(f: (a: A) => boolean): boolean; forall(f: (a: A) => boolean): boolean; flatMap(f: (a: A) => Optional): Optional; foreach(f: (a: A) => void): void; orElse(ob: Optional): Optional<A>; apply1<B, C>(ob: Optional, f: (a: A, b: B) => C): Optional<C>; apply2<B, C, D>(ob: Optional, oc: Optional<C>, f: (a: A, b: B, c: C) => D): Optional<D>; chain(ob: Optional): OptionalBuilder1<A, B>; } export const None: Optional<any>; export function Optional<A>(a: A): Optional<A>; export function Some<A>(a: A): Optional<A>; export class OptionalBuilder1<A, B> { private oa; private ob; constructor(oa: Optional<A>, ob: Optional); run<C>(f: (a: A, b: B) => C): Optional<C>; chain<C>(oc: Optional<C>): OptionalBuilder2<A, B, C>; } export class OptionalBuilder2<A, B, C> { private oa; private ob; private oc; constructor(oa: Optional<A>, ob: Optional, oc: Optional<C>); run<D>(f: (a: A, b: B, c: C) => D): Optional<D>; chain<D>(od: Optional<D>): OptionalBuilder3<A, B, C, D>; } export class OptionalBuilder3<A, B, C, D> { private oa; private ob; private oc; private od; constructor(oa: Optional<A>, ob: Optional, oc: Optional<C>, od: Optional<D>); run<E>(f: (a: A, b: B, c: C, d: D) => E): Optional<E>; chain<E>(oe: Optional<E>): OptionalBuilder4<A, B, C, D, E>; } export class OptionalBuilder4<A, B, C, D, E> { private oa; private ob; private oc; private od; private oe; constructor(oa: Optional<A>, ob: Optional, oc: Optional<C>, od: Optional<D>, oe: Optional<E>); run<F>(f: (a: A, b: B, c: C, d: D, e: E) => F): Optional<F>; chain<F>(of: Optional<F>): OptionalBuilder5<A, B, C, D, E, F>; } export class OptionalBuilder5<A, B, C, D, E, F> { private oa; private ob; private oc; private od; private oe; private of; constructor(oa: Optional<A>, ob: Optional, oc: Optional<C>, od: Optional<D>, oe: Optional<E>, of: Optional<F>); run<G>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => G): Optional<G>; } export interface Try<A> { isSuccess: boolean; isFailure: boolean; get(): A; getError(): Error; fold(fe: (e: Error) => B, ff: (a: A) => B): B; getOrElse(a: B): A; orElse(a: Try): Try<A>; foreach(f: (a: A) => void): void; flatMap(f: (a: A) => Try): Try; map(f: (a: A) => B): Try; filter(f: (a: A) => boolean): Try<A>; toOptional(): Optional<A>; failed(): Try<A>; transform(fs: (a: A) => Try, ff: (e: Error) => Try): Try; recover(f: (e: Error) => Optional<Try>): Try<A>; apply1<B, C>(ob: Try, f: (a: A, b: B) => C): Try<C>; apply2<B, C, D>(ob: Try, oc: Try<C>, f: (a: A, b: B, c: C) => D): Try<D>; chain(ob: Try): TryBuilder1<A, B>; } export function Try<A>(f: () => A): Try<A>; export function Success<A>(a: A): Try<A>; export function Failure<A>(e: Error): Try<A>; export class TryBuilder1<A, B> { private oa; private ob; constructor(oa: Try<A>, ob: Try); run<C>(f: (a: A, b: B) => C): Try<C>; chain<C>(oc: Try<C>): TryBuilder2<A, B, C>; } export class TryBuilder2<A, B, C> { private oa; private ob; private oc; constructor(oa: Try<A>, ob: Try, oc: Try<C>); run<D>(f: (a: A, b: B, c: C) => D): Try<D>; chain<D>(od: Try<D>): TryBuilder3<A, B, C, D>; } export class TryBuilder3<A, B, C, D> { private oa; private ob; private oc; private od; constructor(oa: Try<A>, ob: Try, oc: Try<C>, od: Try<D>); run<E>(f: (a: A, b: B, c: C, d: D) => E): Try<E>; chain<E>(oe: Try<E>): TryBuilder4<A, B, C, D, E>; } export class TryBuilder4<A, B, C, D, E> { private oa; private ob; private oc; private od; private oe; constructor(oa: Try<A>, ob: Try, oc: Try<C>, od: Try<D>, oe: Try<E>); run<F>(f: (a: A, b: B, c: C, d: D, e: E) => F): Try<F>; chain<F>(of: Try<F>): TryBuilder5<A, B, C, D, E, F>; } export class TryBuilder5<A, B, C, D, E, F> { private oa; private ob; private oc; private od; private oe; private of; constructor(oa: Try<A>, ob: Try, oc: Try<C>, od: Try<D>, oe: Try<E>, of: Try<F>); run<G>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => G): Try<G>; } export interface Future<A> { getPromise(): Promise<A>; onComplete(f: (t: Try<A>) => B): void; isCompleted(): boolean; value(): Optional<Try<A>>; failed(): Future<Error>; foreach(f: (a: A) => B): void; transform(f: (t: Try<A>) => Try): Future; transform1(fs: (a: A) => B, ff: (e: Error) => Error): Future; transformWith(f: (t: Try<A>) => Future): Future; map(f: (a: A) => B): Future; flatMap(f: (a: A) => Future): Future; filter(f: (a: A) => boolean): Future<A>; recover(f: (e: Error) => Optional): Future<A>; recoverWith(f: (e: Error) => Optional<Future>): Future<A>; zip(fu: Future): Future<[A, B]>; zipWith<B, C>(fu: Future, f: (a: A, b: B) => C): Future<C>; fallbackTo(fu: Future): Future<A>; andThen(f: (t: Try<A>) => B): Future<A>; apply1<B, C>(ob: Future, f: (a: A, b: B) => C): Future<C>; apply2<B, C, D>(ob: Future, oc: Future<C>, f: (a: A, b: B, c: C) => D): Future<D>; chain(ob: Future): FutureBuilder1<A, B>; } export function Future<A>(f: Promise<A> | (() => A)): Future<A>; export namespace Future { function fromPromise<A>(p: Promise<A>): Future<A>; function unit(): Future<void>; function failed<A>(e: Error): Future<A>; function successful<A>(a: A): Future<A>; function fromTry<A>(t: Try<A>): Future<A>; function sequence<A>(fus: Array<Future<A>>): Future<Array<A>>; function firstCompletedOf<A>(fus: Array<Future<A>>): Future<A>; function find<A>(fus: Array<Future<A>>, f: (a: A) => boolean): Future<Optional<A>>; function foldLeft<A, B>(fu: Array<Future<A>>, zero: B, f: (b: B, a: A) => B): Future; function reduceLeft<A, B>(fu: Array<Future<A>>, f: (b: B, a: A) => B): Future; function traverse<A, B>(fu: Array<A>, f: (a: A) => Future): Future<Array>; } export class FutureBuilder1<A, B> { private oa; private ob; constructor(oa: Future<A>, ob: Future); run<C>(f: (a: A, b: B) => C): Future<C>; chain<C>(oc: Future<C>): FutureBuilder2<A, B, C>; } export class FutureBuilder2<A, B, C> { private oa; private ob; private oc; constructor(oa: Future<A>, ob: Future, oc: Future<C>); run<D>(f: (a: A, b: B, c: C) => D): Future<D>; chain<D>(od: Future<D>): FutureBuilder3<A, B, C, D>; } export class FutureBuilder3<A, B, C, D> { private oa; private ob; private oc; private od; constructor(oa: Future<A>, ob: Future, oc: Future<C>, od: Future<D>); run<E>(f: (a: A, b: B, c: C, d: D) => E): Future<E>; chain<E>(oe: Future<E>): FutureBuilder4<A, B, C, D, E>; } export class FutureBuilder4<A, B, C, D, E> { private oa; private ob; private oc; private od; private oe; constructor(oa: Future<A>, ob: Future, oc: Future<C>, od: Future<D>, oe: Future<E>); run<F>(f: (a: A, b: B, c: C, d: D, e: E) => F): Future<F>; chain<F>(of: Future<F>): FutureBuilder5<A, B, C, D, E, F>; } export class FutureBuilder5<A, B, C, D, E, F> { private oa; private ob; private oc; private od; private oe; private of; constructor(oa: Future<A>, ob: Future, oc: Future<C>, od: Future<D>, oe: Future<E>, of: Future<F>); run<G>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => G): Future<G>; } } declare module "scalike" { export = scalike }