mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
Added scalike
This commit is contained in:
ryoppy
parent
efd40e67ff
commit
efedbd465c
29
scalike/scalike-tests.ts
Normal file
29
scalike/scalike-tests.ts
Normal file
@ -0,0 +1,29 @@
|
||||
/// <reference path="scalike.d.ts" />
|
||||
|
||||
import {Optional, Some, None, Try, Right, Left, Either, Future} from "scalike";
|
||||
|
||||
// Optional
|
||||
Optional(1).map(x => x + 1); // Some(2)
|
||||
Optional(null).map(x => x + 1); // None
|
||||
Optional(undefined).map(x => x + 1); // None
|
||||
Optional(1).flatMap(x => Some(x + 1)).fold(0, x => x + 1); // 3
|
||||
|
||||
// Try
|
||||
function something() { return 1; }
|
||||
Try(something); // Success(1)
|
||||
function throwError() { throw new Error; }
|
||||
Try(throwError); // Failure(Error)
|
||||
Try(() => 1).map(x => x + 1); // Success(2)
|
||||
|
||||
// Either
|
||||
function validate(x: number): Either<string, number> {
|
||||
return x !== 1 ? Left<string, number>('this is not 1') : Right<string, number>(x);
|
||||
}
|
||||
validate(1).right().getOrElse(0); // 1
|
||||
validate(2).left().getOrElse("err"); // "this is not 1"
|
||||
|
||||
// Future
|
||||
Future(something).map(x => x + 1); // Future(2)
|
||||
Future.successful(1).value; // Optional(Success(1)
|
||||
const fu = Future(something);
|
||||
Future.sequence([fu, fu, fu]); // Future([1, 1, 1])
|
||||
271
scalike/scalike.d.ts
vendored
Normal file
271
scalike/scalike.d.ts
vendored
Normal file
@ -0,0 +1,271 @@
|
||||
// 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
|
||||
|
||||
/// <reference path="../es6-promise/es6-promise.d.ts" />
|
||||
|
||||
declare module 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<B>;
|
||||
}
|
||||
|
||||
export interface Optional<A> {
|
||||
isEmpty: boolean;
|
||||
nonEmpty: boolean;
|
||||
get(): A;
|
||||
getOrElse<B extends A>(a: B): A;
|
||||
map<B>(f: (a: A) => B): Optional<B>;
|
||||
fold<B>(ifEmpty: B, f: (a: A) => B): B;
|
||||
flatten(): Optional<A>;
|
||||
filter(f: (a: A) => boolean): Optional<A>;
|
||||
contains<B extends A>(b: B): boolean;
|
||||
exists(f: (a: A) => boolean): boolean;
|
||||
forall(f: (a: A) => boolean): boolean;
|
||||
flatMap<B>(f: (a: A) => Optional<B>): Optional<B>;
|
||||
foreach(f: (a: A) => void): void;
|
||||
orElse<B extends A>(ob: Optional<B>): Optional<A>;
|
||||
apply1<B, C>(ob: Optional<B>, f: (a: A, b: B) => C): Optional<C>;
|
||||
apply2<B, C, D>(ob: Optional<B>, oc: Optional<C>, f: (a: A, b: B, c: C) => D): Optional<D>;
|
||||
chain<B>(ob: Optional<B>): 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<B>);
|
||||
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<B>, 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<B>, 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<B>, 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<B>, 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<B>(fe: (e: Error) => B, ff: (a: A) => B): B;
|
||||
getOrElse<B extends A>(a: B): A;
|
||||
orElse<B extends A>(a: Try<B>): Try<A>;
|
||||
foreach<B>(f: (a: A) => void): void;
|
||||
flatMap<B>(f: (a: A) => Try<B>): Try<B>;
|
||||
map<B>(f: (a: A) => B): Try<B>;
|
||||
filter(f: (a: A) => boolean): Try<A>;
|
||||
toOptional(): Optional<A>;
|
||||
failed(): Try<A>;
|
||||
transform<B>(fs: (a: A) => Try<B>, ff: (e: Error) => Try<B>): Try<B>;
|
||||
recover<B extends A>(f: (e: Error) => Optional<Try<B>>): Try<A>;
|
||||
apply1<B, C>(ob: Try<B>, f: (a: A, b: B) => C): Try<C>;
|
||||
apply2<B, C, D>(ob: Try<B>, oc: Try<C>, f: (a: A, b: B, c: C) => D): Try<D>;
|
||||
chain<B>(ob: Try<B>): 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<B>);
|
||||
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<B>, 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<B>, 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<B>, 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<B>, 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<B>(f: (t: Try<A>) => B): void;
|
||||
isCompleted(): boolean;
|
||||
value(): Optional<Try<A>>;
|
||||
failed(): Future<Error>;
|
||||
foreach<B>(f: (a: A) => B): void;
|
||||
transform<B>(f: (t: Try<A>) => Try<B>): Future<B>;
|
||||
transform1<B>(fs: (a: A) => B, ff: (e: Error) => Error): Future<B>;
|
||||
transformWith<B>(f: (t: Try<A>) => Future<B>): Future<B>;
|
||||
map<B>(f: (a: A) => B): Future<B>;
|
||||
flatMap<B>(f: (a: A) => Future<B>): Future<B>;
|
||||
filter(f: (a: A) => boolean): Future<A>;
|
||||
recover<B extends A>(f: (e: Error) => Optional<B>): Future<A>;
|
||||
recoverWith<B extends A>(f: (e: Error) => Optional<Future<B>>): Future<A>;
|
||||
zip<B>(fu: Future<B>): Future<[A, B]>;
|
||||
zipWith<B, C>(fu: Future<B>, f: (a: A, b: B) => C): Future<C>;
|
||||
fallbackTo<B extends A>(fu: Future<B>): Future<A>;
|
||||
andThen<B>(f: (t: Try<A>) => B): Future<A>;
|
||||
apply1<B, C>(ob: Future<B>, f: (a: A, b: B) => C): Future<C>;
|
||||
apply2<B, C, D>(ob: Future<B>, oc: Future<C>, f: (a: A, b: B, c: C) => D): Future<D>;
|
||||
chain<B>(ob: Future<B>): 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<B>;
|
||||
function reduceLeft<A, B>(fu: Array<Future<A>>, f: (b: B, a: A) => B): Future<B>;
|
||||
function traverse<A, B>(fu: Array<A>, f: (a: A) => Future<B>): Future<Array<B>>;
|
||||
}
|
||||
export class FutureBuilder1<A, B> {
|
||||
private oa;
|
||||
private ob;
|
||||
constructor(oa: Future<A>, ob: Future<B>);
|
||||
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<B>, 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<B>, 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<B>, 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<B>, 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
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user