Page MenuHomePhorge
Files F32160897

D15010.1765041704.diff
No OneTemporary
Actions

Size
19 KB
Referenced Files
None
Subscribers
None

D15010.1765041704.diff
View Options

diff --git a/keyserver/flow-typed/npm/lodash_v4.x.x.js b/keyserver/flow-typed/npm/lodash_v4.x.x.js
--- a/keyserver/flow-typed/npm/lodash_v4.x.x.js
+++ b/keyserver/flow-typed/npm/lodash_v4.x.x.js
@@ -1,6 +1,54 @@
// flow-typed signature: 23d2a3641578673e8eb7c9f8b6bcc3af
// flow-typed version: 6912183195/lodash_v4.x.x/flow_>=v0.201.x
+declare function compose(): <T>(a: T) => T;
+declare function compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+): F;
+declare function compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+): (...T) => R;
+declare function compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+declare function compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
+declare function composeReverse(): <T>(a: T) => T;
+declare function composeReverse<F: (...$ReadOnlyArray<empty>) => mixed>(f: F): F;
+declare function composeReverse<A, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => R,
+): (...T) => R;
+declare function composeReverse<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => R,
+): (...T) => R;
+declare function composeReverse<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => C,
+ f4: (c: C) => R,
+): (...T) => R;
+declare function composeReverse<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
declare module "lodash" {
declare type Path = $ReadOnlyArray<string | number> | string | number;
declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
@@ -1514,8 +1562,8 @@
) => T1)
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(value: T1, defaultValue: T2) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func?: any): Function;
matches(source?: ?Object): Function;
@@ -3464,10 +3512,10 @@
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(defaultValue: T2) => ((value: T1) => T1 | T2))
& (<T1: number, T2>(defaultValue: T2, value: T1) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- pipe: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
- compose: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ pipe: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
+ compose: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func: any): Function;
matches:
diff --git a/keyserver/flow-typed/npm/redux_v4.x.x.js b/keyserver/flow-typed/npm/redux_v4.x.x.js
--- a/keyserver/flow-typed/npm/redux_v4.x.x.js
+++ b/keyserver/flow-typed/npm/redux_v4.x.x.js
@@ -100,5 +100,32 @@
reducers: $ObjMap<RootState, <V>(V) => Reducer<V, A>>,
): Reducer<RootState, A>;
- declare export var compose: $Compose;
+ declare function _compose(): <T>(a: T) => T;
+ declare function _compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+ ): F;
+ declare function _compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+ declare function _compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+
+ declare export var compose: typeof _compose;
}
diff --git a/lib/flow-typed/npm/lodash_v4.x.x.js b/lib/flow-typed/npm/lodash_v4.x.x.js
--- a/lib/flow-typed/npm/lodash_v4.x.x.js
+++ b/lib/flow-typed/npm/lodash_v4.x.x.js
@@ -1,6 +1,54 @@
// flow-typed signature: 23d2a3641578673e8eb7c9f8b6bcc3af
// flow-typed version: 6912183195/lodash_v4.x.x/flow_>=v0.201.x
+declare function compose(): <T>(a: T) => T;
+declare function compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+): F;
+declare function compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+): (...T) => R;
+declare function compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+declare function compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
+declare function composeReverse(): <T>(a: T) => T;
+declare function composeReverse<F: (...$ReadOnlyArray<empty>) => mixed>(f: F): F;
+declare function composeReverse<A, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => R,
+): (...T) => R;
+declare function composeReverse<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => R,
+): (...T) => R;
+declare function composeReverse<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => C,
+ f4: (c: C) => R,
+): (...T) => R;
+declare function composeReverse<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
declare module "lodash" {
declare type Path = $ReadOnlyArray<string | number> | string | number;
declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
@@ -1514,8 +1562,8 @@
) => T1)
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(value: T1, defaultValue: T2) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func?: any): Function;
matches(source?: ?Object): Function;
@@ -3464,10 +3512,10 @@
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(defaultValue: T2) => ((value: T1) => T1 | T2))
& (<T1: number, T2>(defaultValue: T2, value: T1) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- pipe: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
- compose: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ pipe: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
+ compose: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func: any): Function;
matches:
diff --git a/lib/flow-typed/npm/redux_v4.x.x.js b/lib/flow-typed/npm/redux_v4.x.x.js
--- a/lib/flow-typed/npm/redux_v4.x.x.js
+++ b/lib/flow-typed/npm/redux_v4.x.x.js
@@ -100,5 +100,32 @@
reducers: $ObjMap<RootState, <V>(V) => Reducer<V, A>>,
): Reducer<RootState, A>;
- declare export var compose: $Compose;
+ declare function _compose(): <T>(a: T) => T;
+ declare function _compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+ ): F;
+ declare function _compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+ declare function _compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+
+ declare export var compose: typeof _compose;
}
diff --git a/native/flow-typed/npm/lodash_v4.x.x.js b/native/flow-typed/npm/lodash_v4.x.x.js
--- a/native/flow-typed/npm/lodash_v4.x.x.js
+++ b/native/flow-typed/npm/lodash_v4.x.x.js
@@ -1,6 +1,54 @@
// flow-typed signature: 23d2a3641578673e8eb7c9f8b6bcc3af
// flow-typed version: 6912183195/lodash_v4.x.x/flow_>=v0.201.x
+declare function compose(): <T>(a: T) => T;
+declare function compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+): F;
+declare function compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+): (...T) => R;
+declare function compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+declare function compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
+declare function composeReverse(): <T>(a: T) => T;
+declare function composeReverse<F: (...$ReadOnlyArray<empty>) => mixed>(f: F): F;
+declare function composeReverse<A, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => R,
+): (...T) => R;
+declare function composeReverse<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => R,
+): (...T) => R;
+declare function composeReverse<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => C,
+ f4: (c: C) => R,
+): (...T) => R;
+declare function composeReverse<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
declare module "lodash" {
declare type Path = $ReadOnlyArray<string | number> | string | number;
declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
@@ -1514,8 +1562,8 @@
) => T1)
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(value: T1, defaultValue: T2) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func?: any): Function;
matches(source?: ?Object): Function;
@@ -3464,10 +3512,10 @@
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(defaultValue: T2) => ((value: T1) => T1 | T2))
& (<T1: number, T2>(defaultValue: T2, value: T1) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- pipe: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
- compose: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ pipe: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
+ compose: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func: any): Function;
matches:
diff --git a/native/flow-typed/npm/redux_v4.x.x.js b/native/flow-typed/npm/redux_v4.x.x.js
--- a/native/flow-typed/npm/redux_v4.x.x.js
+++ b/native/flow-typed/npm/redux_v4.x.x.js
@@ -97,8 +97,35 @@
): C;
declare export function combineReducers<RootState: {...}, A>(
- reducers: $ObjMap<RootState, <V>(V) => Reducer<V, A>>,
+ reducers: {[K in keyof RootState]: Reducer<RootState[K], A>}
): Reducer<RootState, A>;
- declare export var compose: $Compose;
+ declare function _compose(): <T>(a: T) => T;
+ declare function _compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+ ): F;
+ declare function _compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+ declare function _compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+
+ declare export var compose: typeof _compose;
}
diff --git a/web/flow-typed/npm/lodash_v4.x.x.js b/web/flow-typed/npm/lodash_v4.x.x.js
--- a/web/flow-typed/npm/lodash_v4.x.x.js
+++ b/web/flow-typed/npm/lodash_v4.x.x.js
@@ -1,6 +1,54 @@
// flow-typed signature: 23d2a3641578673e8eb7c9f8b6bcc3af
// flow-typed version: 6912183195/lodash_v4.x.x/flow_>=v0.201.x
+declare function compose(): <T>(a: T) => T;
+declare function compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+): F;
+declare function compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+): (...T) => R;
+declare function compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+): (...T) => R;
+declare function compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+declare function compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
+declare function composeReverse(): <T>(a: T) => T;
+declare function composeReverse<F: (...$ReadOnlyArray<empty>) => mixed>(f: F): F;
+declare function composeReverse<A, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => R,
+): (...T) => R;
+declare function composeReverse<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => R,
+): (...T) => R;
+declare function composeReverse<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (...T) => A,
+ f2: (a: A) => B,
+ f3: (b: B) => C,
+ f4: (c: C) => R,
+): (...T) => R;
+declare function composeReverse<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+): (...$ReadOnlyArray<any>) => R;
+
declare module "lodash" {
declare type Path = $ReadOnlyArray<string | number> | string | number;
declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
@@ -1514,8 +1562,8 @@
) => T1)
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(value: T1, defaultValue: T2) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func?: any): Function;
matches(source?: ?Object): Function;
@@ -3464,10 +3512,10 @@
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(defaultValue: T2) => ((value: T1) => T1 | T2))
& (<T1: number, T2>(defaultValue: T2, value: T1) => T1 | T2);
- flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- pipe: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
- flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
- compose: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
+ flow: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ pipe: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof composeReverse;
+ flowRight: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
+ compose: ((funcs: $ReadOnlyArray<Function>) => Function) & typeof compose;
identity<T>(value: T): T;
iteratee(func: any): Function;
matches:
diff --git a/web/flow-typed/npm/redux_v4.x.x.js b/web/flow-typed/npm/redux_v4.x.x.js
--- a/web/flow-typed/npm/redux_v4.x.x.js
+++ b/web/flow-typed/npm/redux_v4.x.x.js
@@ -97,8 +97,35 @@
): C;
declare export function combineReducers<RootState: {...}, A>(
- reducers: $ObjMap<RootState, <V>(V) => Reducer<V, A>>,
+ reducers: {[K in keyof RootState]: Reducer<RootState[K], A>}
): Reducer<RootState, A>;
- declare export var compose: $Compose;
+ declare function _compose(): <T>(a: T) => T;
+ declare function _compose<F: (...$ReadOnlyArray<empty>) => mixed>(
+ f: F,
+ ): F;
+ declare function _compose<A, T: $ReadOnlyArray<any>, R>(
+ f1: (a: A) => R,
+ f2: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, T: $ReadOnlyArray<any>, R>(
+ f1: (b: B) => R,
+ f2: (a: A) => B,
+ f3: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<A, B, C, T: $ReadOnlyArray<any>, R>(
+ f1: (c: C) => R,
+ f2: (b: B) => C,
+ f3: (a: A) => B,
+ f4: (...T) => A,
+ ): (...T) => R;
+ declare function _compose<R>(
+ f1: (b: any) => R,
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+ declare function _compose<R>(
+ ...funcs: $ReadOnlyArray<(...$ReadOnlyArray<empty>) => mixed>
+ ): (...$ReadOnlyArray<any>) => R;
+
+ declare export var compose: typeof _compose;
}

File Metadata

Mime Type
text/plain
Expires
Sat, Dec 6, 5:21 PM (3 h, 32 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5839766
Default Alt Text
D15010.1765041704.diff (19 KB)

Event Timeline