Brunobkr/llama.cpp_AlgMor24_github

1/**2 * This file provides type definitions for use with the Flow type checker.3 *4 * An important caveat when using these definitions is that the types for5 * `Collection.Keyed`, `Collection.Indexed`, `Seq.Keyed`, and so on are stubs.6 * When referring to those types, you can get the proper definitions by7 * importing the types `KeyedCollection`, `IndexedCollection`, `KeyedSeq`, etc.8 * For example,9 *10 *     import { Seq } from 'immutable'11 *     import type { IndexedCollection, IndexedSeq } from 'immutable'12 *13 *     const someSeq: IndexedSeq<number> = Seq.Indexed.of(1, 2, 3)14 *15 *     function takesASeq<T, TS: IndexedCollection<T>>(iter: TS): TS {16 *       return iter.butLast()17 *     }18 *19 *     takesASeq(someSeq)20 *21 * @flow strict22 */23 24// Helper type that represents plain objects allowed as arguments to25// some constructors and functions.26type PlainObjInput<K, V> = { +[key: K]: V, __proto__: null };27 28type K<T> = $Keys<T>;29 30// Helper types to extract the "keys" and "values" use by the *In() methods.31type $KeyOf<C> = $Call<32  (<K>(?_Collection<K, mixed>) => K) &33    (<T>(?$ReadOnlyArray<T>) => number) &34    (<T>(?RecordInstance<T> | T) => $Keys<T>) &35    (<T: Object>(T) => $Keys<T>),36  C,37>;38 39type $ValOf<C, K = $KeyOf<C>> = $Call<40  (<V>(?_Collection<any, V>) => V) &41    (<T>(?$ReadOnlyArray<T>) => T) &42    (<T, K: $Keys<T>>(?RecordInstance<T> | T, K) => $ElementType<T, K>) &43    (<T: Object>(T) => $Values<T>),44  C,45  K,46>;47 48type $IterableOf<C> = $Call<49  (<V: Array<any> | IndexedCollection<any> | SetCollection<any>>(50    V51  ) => Iterable<$ValOf<V>>) &52    (<53      V:54        | KeyedCollection<any, any>55        | RecordInstance<any>56        | PlainObjInput<any, any>,57    >(58      V59    ) => Iterable<[$KeyOf<V>, $ValOf<V>]>),60  C,61>;62 63const PairSorting: $ReadOnly<{ LeftThenRight: number, RightThenLeft: number }> =64  {65    LeftThenRight: -1,66    RightThenLeft: +1,67  };68 69type Comparator<T> = (left: T, right: T) => number;70 71declare class _Collection<K, +V> implements ValueObject {72  equals(other: mixed): boolean;73  hashCode(): number;74  get(key: K, ..._: []): V | void;75  get<NSV>(key: K, notSetValue: NSV): V | NSV;76  has(key: K): boolean;77  includes(value: V): boolean;78  contains(value: V): boolean;79  first(): V | void;80  first<NSV>(notSetValue: NSV): V | NSV;81  last(): V | void;82  last<NSV>(notSetValue: NSV): V | NSV;83 84  hasIn(keyPath: Iterable<mixed>): boolean;85 86  getIn(keyPath: [], notSetValue?: mixed): this;87  getIn<NSV>(keyPath: [K], notSetValue: NSV): V | NSV;88  getIn<NSV, K2: $KeyOf<V>>(89    keyPath: [K, K2],90    notSetValue: NSV91  ): $ValOf<V, K2> | NSV;92  getIn<NSV, K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(93    keyPath: [K, K2, K3],94    notSetValue: NSV95  ): $ValOf<$ValOf<V, K2>, K3> | NSV;96  getIn<97    NSV,98    K2: $KeyOf<V>,99    K3: $KeyOf<$ValOf<V, K2>>,100    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,101  >(102    keyPath: [K, K2, K3, K4],103    notSetValue: NSV104  ): $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4> | NSV;105  getIn<106    NSV,107    K2: $KeyOf<V>,108    K3: $KeyOf<$ValOf<V, K2>>,109    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,110    K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,111  >(112    keyPath: [K, K2, K3, K4, K5],113    notSetValue: NSV114  ): $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5> | NSV;115 116  update<U>(updater: (value: this) => U): U;117 118  toJS(): Array<any> | { [key: string]: mixed };119  toJSON(): Array<V> | { [key: string]: V };120  toArray(): Array<V> | Array<[K, V]>;121  toObject(): { [key: string]: V };122  toMap(): Map<K, V>;123  toOrderedMap(): OrderedMap<K, V>;124  toSet(): Set<V>;125  toOrderedSet(): OrderedSet<V>;126  toList(): List<V>;127  toStack(): Stack<V>;128  toSeq(): Seq<K, V>;129  toKeyedSeq(): KeyedSeq<K, V>;130  toIndexedSeq(): IndexedSeq<V>;131  toSetSeq(): SetSeq<V>;132 133  keys(): Iterator<K>;134  values(): Iterator<V>;135  entries(): Iterator<[K, V]>;136 137  keySeq(): IndexedSeq<K>;138  valueSeq(): IndexedSeq<V>;139  entrySeq(): IndexedSeq<[K, V]>;140 141  reverse(): this;142  sort(comparator?: Comparator<V>): this;143 144  sortBy<C>(145    comparatorValueMapper: (value: V, key: K, iter: this) => C,146    comparator?: Comparator<C>147  ): this;148 149  groupBy<G>(150    grouper: (value: V, key: K, iter: this) => G,151    context?: mixed152  ): KeyedSeq<G, this>;153 154  forEach(155    sideEffect: (value: V, key: K, iter: this) => any,156    context?: mixed157  ): number;158 159  slice(begin?: number, end?: number): this;160  rest(): this;161  butLast(): this;162  skip(amount: number): this;163  skipLast(amount: number): this;164  skipWhile(165    predicate: (value: V, key: K, iter: this) => mixed,166    context?: mixed167  ): this;168  skipUntil(169    predicate: (value: V, key: K, iter: this) => mixed,170    context?: mixed171  ): this;172  take(amount: number): this;173  takeLast(amount: number): this;174  takeWhile(175    predicate: (value: V, key: K, iter: this) => mixed,176    context?: mixed177  ): this;178  takeUntil(179    predicate: (value: V, key: K, iter: this) => mixed,180    context?: mixed181  ): this;182 183  filterNot(184    predicate: (value: V, key: K, iter: this) => mixed,185    context?: mixed186  ): this;187 188  reduce<R>(189    reducer: (reduction: R, value: V, key: K, iter: this) => R,190    initialReduction: R,191    context?: mixed192  ): R;193  reduce<R>(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R;194 195  reduceRight<R>(196    reducer: (reduction: R, value: V, key: K, iter: this) => R,197    initialReduction: R,198    context?: mixed199  ): R;200  reduceRight<R>(201    reducer: (reduction: V | R, value: V, key: K, iter: this) => R202  ): R;203 204  every(205    predicate: (value: V, key: K, iter: this) => mixed,206    context?: mixed207  ): boolean;208  some(209    predicate: (value: V, key: K, iter: this) => mixed,210    context?: mixed211  ): boolean;212  join(separator?: string): string;213  isEmpty(): boolean;214  count(215    predicate?: (value: V, key: K, iter: this) => mixed,216    context?: mixed217  ): number;218  countBy<G>(219    grouper: (value: V, key: K, iter: this) => G,220    context?: mixed221  ): Map<G, number>;222 223  find(224    predicate: (value: V, key: K, iter: this) => mixed,225    context?: mixed,226    notSetValue?: V227  ): V | void;228  findLast(229    predicate: (value: V, key: K, iter: this) => mixed,230    context?: mixed,231    notSetValue?: V232  ): V | void;233 234  findEntry(predicate: (value: V, key: K, iter: this) => mixed): [K, V] | void;235  findLastEntry(236    predicate: (value: V, key: K, iter: this) => mixed237  ): [K, V] | void;238 239  findKey(240    predicate: (value: V, key: K, iter: this) => mixed,241    context?: mixed242  ): K | void;243  findLastKey(244    predicate: (value: V, key: K, iter: this) => mixed,245    context?: mixed246  ): K | void;247 248  keyOf(searchValue: V): K | void;249  lastKeyOf(searchValue: V): K | void;250 251  max(comparator?: Comparator<V>): V;252  maxBy<C>(253    comparatorValueMapper: (value: V, key: K, iter: this) => C,254    comparator?: Comparator<C>255  ): V;256  min(comparator?: Comparator<V>): V;257  minBy<C>(258    comparatorValueMapper: (value: V, key: K, iter: this) => C,259    comparator?: Comparator<C>260  ): V;261 262  isSubset(iter: Iterable<V>): boolean;263  isSuperset(iter: Iterable<V>): boolean;264}265 266declare function isImmutable(267  maybeImmutable: mixed268): boolean %checks(maybeImmutable instanceof Collection);269declare function isCollection(270  maybeCollection: mixed271): boolean %checks(maybeCollection instanceof Collection);272declare function isKeyed(273  maybeKeyed: mixed274): boolean %checks(maybeKeyed instanceof KeyedCollection);275declare function isIndexed(276  maybeIndexed: mixed277): boolean %checks(maybeIndexed instanceof IndexedCollection);278declare function isAssociative(279  maybeAssociative: mixed280): boolean %checks(maybeAssociative instanceof KeyedCollection ||281  maybeAssociative instanceof IndexedCollection);282declare function isOrdered(283  maybeOrdered: mixed284): boolean %checks(maybeOrdered instanceof IndexedCollection ||285  maybeOrdered instanceof OrderedMap ||286  maybeOrdered instanceof OrderedSet);287declare function isValueObject(maybeValue: mixed): boolean;288 289declare function isSeq(maybeSeq: any): boolean %checks(maybeSeq instanceof Seq);290declare function isList(maybeList: any): boolean %checks(maybeList instanceof291  List);292declare function isMap(maybeMap: any): boolean %checks(maybeMap instanceof Map);293declare function isOrderedMap(294  maybeOrderedMap: any295): boolean %checks(maybeOrderedMap instanceof OrderedMap);296declare function isStack(maybeStack: any): boolean %checks(maybeStack instanceof297  Stack);298declare function isSet(maybeSet: any): boolean %checks(maybeSet instanceof Set);299declare function isOrderedSet(300  maybeOrderedSet: any301): boolean %checks(maybeOrderedSet instanceof OrderedSet);302declare function isRecord(303  maybeRecord: any304): boolean %checks(maybeRecord instanceof Record);305 306declare interface ValueObject {307  equals(other: mixed): boolean;308  hashCode(): number;309}310 311declare class Collection<K, +V> extends _Collection<K, V> {312  static Keyed: typeof KeyedCollection;313  static Indexed: typeof IndexedCollection;314  static Set: typeof SetCollection;315 316  static isCollection: typeof isCollection;317  static isKeyed: typeof isKeyed;318  static isIndexed: typeof isIndexed;319  static isAssociative: typeof isAssociative;320  static isOrdered: typeof isOrdered;321}322 323declare class KeyedCollection<K, +V> extends Collection<K, V> {324  static <K, V>(325    values?: Iterable<[K, V]> | PlainObjInput<K, V>326  ): KeyedCollection<K, V>;327 328  toJS(): { [key: string]: mixed };329  toJSON(): { [key: string]: V };330  toArray(): Array<[K, V]>;331  @@iterator(): Iterator<[K, V]>;332  toSeq(): KeyedSeq<K, V>;333  flip(): KeyedCollection<V, K>;334 335  concat<KC, VC>(336    ...iters: Array<Iterable<[KC, VC]> | PlainObjInput<KC, VC>>337  ): KeyedCollection<K | KC, V | VC>;338 339  filter(predicate: typeof Boolean): KeyedCollection<K, $NonMaybeType<V>>;340  filter(341    predicate: (value: V, key: K, iter: this) => mixed,342    context?: mixed343  ): KeyedCollection<K, V>;344 345  partition(346    predicate: (value: V, key: K, iter: this) => mixed,347    context?: mixed348  ): [this, this];349 350  map<M>(351    mapper: (value: V, key: K, iter: this) => M,352    context?: mixed353  ): KeyedCollection<K, M>;354 355  mapKeys<M>(356    mapper: (key: K, value: V, iter: this) => M,357    context?: mixed358  ): KeyedCollection<M, V>;359 360  mapEntries<KM, VM>(361    mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],362    context?: mixed363  ): KeyedCollection<KM, VM>;364 365  flatMap<KM, VM>(366    mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,367    context?: mixed368  ): KeyedCollection<KM, VM>;369 370  flatten(depth?: number): KeyedCollection<any, any>;371  flatten(shallow?: boolean): KeyedCollection<any, any>;372}373 374Collection.Keyed = KeyedCollection;375 376declare class IndexedCollection<+T> extends Collection<number, T> {377  static <T>(iter?: Iterable<T>): IndexedCollection<T>;378 379  toJS(): Array<mixed>;380  toJSON(): Array<T>;381  toArray(): Array<T>;382  @@iterator(): Iterator<T>;383  toSeq(): IndexedSeq<T>;384  fromEntrySeq<K, V>(): KeyedSeq<K, V>;385  interpose(separator: T): this;386  interleave(...collections: Iterable<T>[]): this;387  splice(index: number, removeNum: number, ...values: T[]): this;388 389  zip<A>(a: Iterable<A>, ..._: []): IndexedCollection<[T, A]>;390  zip<A, B>(391    a: Iterable<A>,392    b: Iterable<B>,393    ..._: []394  ): IndexedCollection<[T, A, B]>;395  zip<A, B, C>(396    a: Iterable<A>,397    b: Iterable<B>,398    c: Iterable<C>,399    ..._: []400  ): IndexedCollection<[T, A, B, C]>;401  zip<A, B, C, D>(402    a: Iterable<A>,403    b: Iterable<B>,404    c: Iterable<C>,405    d: Iterable<D>,406    ..._: []407  ): IndexedCollection<[T, A, B, C, D]>;408  zip<A, B, C, D, E>(409    a: Iterable<A>,410    b: Iterable<B>,411    c: Iterable<C>,412    d: Iterable<D>,413    e: Iterable<E>,414    ..._: []415  ): IndexedCollection<[T, A, B, C, D, E]>;416 417  zipAll<A>(a: Iterable<A>, ..._: []): IndexedCollection<[T | void, A | void]>;418  zipAll<A, B>(419    a: Iterable<A>,420    b: Iterable<B>,421    ..._: []422  ): IndexedCollection<[T | void, A | void, B | void]>;423  zipAll<A, B, C>(424    a: Iterable<A>,425    b: Iterable<B>,426    c: Iterable<C>,427    ..._: []428  ): IndexedCollection<[T | void, A | void, B | void, C | void]>;429  zipAll<A, B, C, D>(430    a: Iterable<A>,431    b: Iterable<B>,432    c: Iterable<C>,433    d: Iterable<D>,434    ..._: []435  ): IndexedCollection<[T | void, A | void, B | void, C | void, D | void]>;436  zipAll<A, B, C, D, E>(437    a: Iterable<A>,438    b: Iterable<B>,439    c: Iterable<C>,440    d: Iterable<D>,441    e: Iterable<E>,442    ..._: []443  ): IndexedCollection<444    [T | void, A | void, B | void, C | void, D | void, E | void],445  >;446 447  zipWith<A, R>(448    zipper: (value: T, a: A) => R,449    a: Iterable<A>,450    ..._: []451  ): IndexedCollection<R>;452  zipWith<A, B, R>(453    zipper: (value: T, a: A, b: B) => R,454    a: Iterable<A>,455    b: Iterable<B>,456    ..._: []457  ): IndexedCollection<R>;458  zipWith<A, B, C, R>(459    zipper: (value: T, a: A, b: B, c: C) => R,460    a: Iterable<A>,461    b: Iterable<B>,462    c: Iterable<C>,463    ..._: []464  ): IndexedCollection<R>;465  zipWith<A, B, C, D, R>(466    zipper: (value: T, a: A, b: B, c: C, d: D) => R,467    a: Iterable<A>,468    b: Iterable<B>,469    c: Iterable<C>,470    d: Iterable<D>,471    ..._: []472  ): IndexedCollection<R>;473  zipWith<A, B, C, D, E, R>(474    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,475    a: Iterable<A>,476    b: Iterable<B>,477    c: Iterable<C>,478    d: Iterable<D>,479    e: Iterable<E>,480    ..._: []481  ): IndexedCollection<R>;482 483  indexOf(searchValue: T): number;484  lastIndexOf(searchValue: T): number;485  findIndex(486    predicate: (value: T, index: number, iter: this) => mixed,487    context?: mixed488  ): number;489  findLastIndex(490    predicate: (value: T, index: number, iter: this) => mixed,491    context?: mixed492  ): number;493 494  concat<C>(...iters: Array<Iterable<C> | C>): IndexedCollection<T | C>;495 496  filter(predicate: typeof Boolean): IndexedCollection<$NonMaybeType<T>>;497  filter(498    predicate: (value: T, index: number, iter: this) => mixed,499    context?: mixed500  ): IndexedCollection<T>;501 502  partition(503    predicate: (value: T, index: number, iter: this) => mixed,504    context?: mixed505  ): [this, this];506 507  map<M>(508    mapper: (value: T, index: number, iter: this) => M,509    context?: mixed510  ): IndexedCollection<M>;511 512  flatMap<M>(513    mapper: (value: T, index: number, iter: this) => Iterable<M>,514    context?: mixed515  ): IndexedCollection<M>;516 517  flatten(depth?: number): IndexedCollection<any>;518  flatten(shallow?: boolean): IndexedCollection<any>;519}520 521declare class SetCollection<+T> extends Collection<T, T> {522  static <T>(iter?: Iterable<T>): SetCollection<T>;523 524  toJS(): Array<mixed>;525  toJSON(): Array<T>;526  toArray(): Array<T>;527  @@iterator(): Iterator<T>;528  toSeq(): SetSeq<T>;529 530  concat<U>(...collections: Iterable<U>[]): SetCollection<T | U>;531 532  // `filter`, `map` and `flatMap` cannot be defined further up the hierarchy,533  // because the implementation for `KeyedCollection` allows the value type to534  // change without constraining the key type. That does not work for535  // `SetCollection` - the value and key types *must* match.536  filter(predicate: typeof Boolean): SetCollection<$NonMaybeType<T>>;537  filter(538    predicate: (value: T, value: T, iter: this) => mixed,539    context?: mixed540  ): SetCollection<T>;541 542  partition(543    predicate: (value: T, value: T, iter: this) => mixed,544    context?: mixed545  ): [this, this];546 547  map<M>(548    mapper: (value: T, value: T, iter: this) => M,549    context?: mixed550  ): SetCollection<M>;551 552  flatMap<M>(553    mapper: (value: T, value: T, iter: this) => Iterable<M>,554    context?: mixed555  ): SetCollection<M>;556 557  flatten(depth?: number): SetCollection<any>;558  flatten(shallow?: boolean): SetCollection<any>;559}560 561declare function isSeq(maybeSeq: mixed): boolean %checks(maybeSeq instanceof562  Seq);563declare class Seq<K, +V> extends _Collection<K, V> {564  static Keyed: typeof KeyedSeq;565  static Indexed: typeof IndexedSeq;566  static Set: typeof SetSeq;567 568  static <K, V>(values: KeyedSeq<K, V>): KeyedSeq<K, V>;569  static <T>(values: SetSeq<T>): SetSeq<K, V>;570  static <T>(values: Iterable<T>): IndexedSeq<T>;571  static <K, V>(values?: PlainObjInput<K, V>): KeyedSeq<K, V>;572 573  static isSeq: typeof isSeq;574 575  size: number | void;576  cacheResult(): this;577  toSeq(): this;578}579 580declare class KeyedSeq<K, +V> extends Seq<K, V> mixins KeyedCollection<K, V> {581  static <K, V>(582    values?: Iterable<[K, V]> | PlainObjInput<K, V>583  ): KeyedSeq<K, V>;584 585  // Override specialized return types586  flip(): KeyedSeq<V, K>;587 588  concat<KC, VC>(589    ...iters: Array<Iterable<[KC, VC]> | PlainObjInput<KC, VC>>590  ): KeyedSeq<K | KC, V | VC>;591 592  filter(predicate: typeof Boolean): KeyedSeq<K, $NonMaybeType<V>>;593  filter(594    predicate: (value: V, key: K, iter: this) => mixed,595    context?: mixed596  ): KeyedSeq<K, V>;597 598  partition(599    predicate: (value: V, key: K, iter: this) => mixed,600    context?: mixed601  ): [this, this];602 603  map<M>(604    mapper: (value: V, key: K, iter: this) => M,605    context?: mixed606  ): KeyedSeq<K, M>;607 608  mapKeys<M>(609    mapper: (key: K, value: V, iter: this) => M,610    context?: mixed611  ): KeyedSeq<M, V>;612 613  mapEntries<KM, VM>(614    mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],615    context?: mixed616  ): KeyedSeq<KM, VM>;617 618  flatMap<KM, VM>(619    mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,620    context?: mixed621  ): KeyedSeq<KM, VM>;622 623  flatten(depth?: number): KeyedSeq<any, any>;624  flatten(shallow?: boolean): KeyedSeq<any, any>;625}626 627declare class IndexedSeq<+T>628  extends Seq<number, T>629  mixins IndexedCollection<T>630{631  static <T>(values?: Iterable<T>): IndexedSeq<T>;632 633  static of<T>(...values: T[]): IndexedSeq<T>;634 635  // Override specialized return types636 637  concat<C>(...iters: Array<Iterable<C> | C>): IndexedSeq<T | C>;638 639  filter(predicate: typeof Boolean): IndexedSeq<$NonMaybeType<T>>;640  filter(641    predicate: (value: T, index: number, iter: this) => mixed,642    context?: mixed643  ): IndexedSeq<T>;644 645  partition(646    predicate: (value: T, index: number, iter: this) => mixed,647    context?: mixed648  ): [this, this];649 650  map<M>(651    mapper: (value: T, index: number, iter: this) => M,652    context?: mixed653  ): IndexedSeq<M>;654 655  flatMap<M>(656    mapper: (value: T, index: number, iter: this) => Iterable<M>,657    context?: mixed658  ): IndexedSeq<M>;659 660  flatten(depth?: number): IndexedSeq<any>;661  flatten(shallow?: boolean): IndexedSeq<any>;662 663  zip<A>(a: Iterable<A>, ..._: []): IndexedSeq<[T, A]>;664  zip<A, B>(a: Iterable<A>, b: Iterable<B>, ..._: []): IndexedSeq<[T, A, B]>;665  zip<A, B, C>(666    a: Iterable<A>,667    b: Iterable<B>,668    c: Iterable<C>,669    ..._: []670  ): IndexedSeq<[T, A, B, C]>;671  zip<A, B, C, D>(672    a: Iterable<A>,673    b: Iterable<B>,674    c: Iterable<C>,675    d: Iterable<D>,676    ..._: []677  ): IndexedSeq<[T, A, B, C, D]>;678  zip<A, B, C, D, E>(679    a: Iterable<A>,680    b: Iterable<B>,681    c: Iterable<C>,682    d: Iterable<D>,683    e: Iterable<E>,684    ..._: []685  ): IndexedSeq<[T, A, B, C, D, E]>;686 687  zipAll<A>(a: Iterable<A>, ..._: []): IndexedSeq<[T | void, A | void]>;688  zipAll<A, B>(689    a: Iterable<A>,690    b: Iterable<B>,691    ..._: []692  ): IndexedSeq<[T | void, A | void, B | void]>;693  zipAll<A, B, C>(694    a: Iterable<A>,695    b: Iterable<B>,696    c: Iterable<C>,697    ..._: []698  ): IndexedSeq<[T | void, A | void, B | void, C | void]>;699  zipAll<A, B, C, D>(700    a: Iterable<A>,701    b: Iterable<B>,702    c: Iterable<C>,703    d: Iterable<D>,704    ..._: []705  ): IndexedSeq<[T | void, A | void, B | void, C | void, D | void]>;706  zipAll<A, B, C, D, E>(707    a: Iterable<A>,708    b: Iterable<B>,709    c: Iterable<C>,710    d: Iterable<D>,711    e: Iterable<E>,712    ..._: []713  ): IndexedSeq<[T | void, A | void, B | void, C | void, D | void, E | void]>;714 715  zipWith<A, R>(716    zipper: (value: T, a: A) => R,717    a: Iterable<A>,718    ..._: []719  ): IndexedSeq<R>;720  zipWith<A, B, R>(721    zipper: (value: T, a: A, b: B) => R,722    a: Iterable<A>,723    b: Iterable<B>,724    ..._: []725  ): IndexedSeq<R>;726  zipWith<A, B, C, R>(727    zipper: (value: T, a: A, b: B, c: C) => R,728    a: Iterable<A>,729    b: Iterable<B>,730    c: Iterable<C>,731    ..._: []732  ): IndexedSeq<R>;733  zipWith<A, B, C, D, R>(734    zipper: (value: T, a: A, b: B, c: C, d: D) => R,735    a: Iterable<A>,736    b: Iterable<B>,737    c: Iterable<C>,738    d: Iterable<D>,739    ..._: []740  ): IndexedSeq<R>;741  zipWith<A, B, C, D, E, R>(742    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,743    a: Iterable<A>,744    b: Iterable<B>,745    c: Iterable<C>,746    d: Iterable<D>,747    e: Iterable<E>,748    ..._: []749  ): IndexedSeq<R>;750}751 752declare class SetSeq<+T> extends Seq<T, T> mixins SetCollection<T> {753  static <T>(values?: Iterable<T>): SetSeq<T>;754 755  static of<T>(...values: T[]): SetSeq<T>;756 757  // Override specialized return types758 759  concat<U>(...collections: Iterable<U>[]): SetSeq<T | U>;760 761  filter(predicate: typeof Boolean): SetSeq<$NonMaybeType<T>>;762  filter(763    predicate: (value: T, value: T, iter: this) => mixed,764    context?: mixed765  ): SetSeq<T>;766 767  partition(768    predicate: (value: T, value: T, iter: this) => mixed,769    context?: mixed770  ): [this, this];771 772  map<M>(773    mapper: (value: T, value: T, iter: this) => M,774    context?: mixed775  ): SetSeq<M>;776 777  flatMap<M>(778    mapper: (value: T, value: T, iter: this) => Iterable<M>,779    context?: mixed780  ): SetSeq<M>;781 782  flatten(depth?: number): SetSeq<any>;783  flatten(shallow?: boolean): SetSeq<any>;784}785 786declare class UpdatableInCollection<K, +V> {787  setIn<S>(keyPath: [], value: S): S;788  setIn(keyPath: [K], value: V): this;789  setIn<K2: $KeyOf<V>, S: $ValOf<V, K2>>(keyPath: [K, K2], value: S): this;790  setIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, S: $ValOf<$ValOf<V, K2>, K3>>(791    keyPath: [K, K2, K3],792    value: S793  ): this;794  setIn<795    K2: $KeyOf<V>,796    K3: $KeyOf<$ValOf<V, K2>>,797    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,798    S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>,799  >(800    keyPath: [K, K2, K3, K4],801    value: S802  ): this;803  setIn<804    K2: $KeyOf<V>,805    K3: $KeyOf<$ValOf<V, K2>>,806    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,807    K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,808    S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>,809  >(810    keyPath: [K, K2, K3, K4, K5],811    value: S812  ): this;813 814  deleteIn(keyPath: []): void;815  deleteIn(keyPath: [K]): this;816  deleteIn<K2: $KeyOf<V>>(keyPath: [K, K2]): this;817  deleteIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(818    keyPath: [K, K2, K3]819  ): this;820  deleteIn<821    K2: $KeyOf<V>,822    K3: $KeyOf<$ValOf<V, K2>>,823    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,824  >(825    keyPath: [K, K2, K3, K4]826  ): this;827  deleteIn<828    K2: $KeyOf<V>,829    K3: $KeyOf<$ValOf<V, K2>>,830    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,831    K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,832  >(833    keyPath: [K, K2, K3, K4, K5]834  ): this;835 836  removeIn(keyPath: []): void;837  removeIn(keyPath: [K]): this;838  removeIn<K2: $KeyOf<V>>(keyPath: [K, K2]): this;839  removeIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(840    keyPath: [K, K2, K3]841  ): this;842  removeIn<843    K2: $KeyOf<V>,844    K3: $KeyOf<$ValOf<V, K2>>,845    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,846  >(847    keyPath: [K, K2, K3, K4]848  ): this;849  removeIn<850    K2: $KeyOf<V>,851    K3: $KeyOf<$ValOf<V, K2>>,852    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,853    K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,854  >(855    keyPath: [K, K2, K3, K4, K5]856  ): this;857 858  updateIn<U>(keyPath: [], notSetValue: mixed, updater: (value: this) => U): U;859  updateIn<U>(keyPath: [], updater: (value: this) => U): U;860  updateIn<NSV>(keyPath: [K], notSetValue: NSV, updater: (value: V) => V): this;861  updateIn(keyPath: [K], updater: (value: V) => V): this;862  updateIn<NSV, K2: $KeyOf<V>, S: $ValOf<V, K2>>(863    keyPath: [K, K2],864    notSetValue: NSV,865    updater: (value: $ValOf<V, K2> | NSV) => S866  ): this;867  updateIn<K2: $KeyOf<V>, S: $ValOf<V, K2>>(868    keyPath: [K, K2],869    updater: (value: $ValOf<V, K2>) => S870  ): this;871  updateIn<872    NSV,873    K2: $KeyOf<V>,874    K3: $KeyOf<$ValOf<V, K2>>,875    S: $ValOf<$ValOf<V, K2>, K3>,876  >(877    keyPath: [K, K2, K3],878    notSetValue: NSV,879    updater: (value: $ValOf<$ValOf<V, K2>, K3> | NSV) => S880  ): this;881  updateIn<882    K2: $KeyOf<V>,883    K3: $KeyOf<$ValOf<V, K2>>,884    S: $ValOf<$ValOf<V, K2>, K3>,885  >(886    keyPath: [K, K2, K3],887    updater: (value: $ValOf<$ValOf<V, K2>, K3>) => S888  ): this;889  updateIn<890    NSV,891    K2: $KeyOf<V>,892    K3: $KeyOf<$ValOf<V, K2>>,893    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,894    S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>,895  >(896    keyPath: [K, K2, K3, K4],897    notSetValue: NSV,898    updater: (value: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4> | NSV) => S899  ): this;900  updateIn<901    K2: $KeyOf<V>,902    K3: $KeyOf<$ValOf<V, K2>>,903    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,904    S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>,905  >(906    keyPath: [K, K2, K3, K4],907    updater: (value: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>) => S908  ): this;909  updateIn<910    NSV,911    K2: $KeyOf<V>,912    K3: $KeyOf<$ValOf<V, K2>>,913    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,914    K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,915    S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>,916  >(917    keyPath: [K, K2, K3, K4, K5],918    notSetValue: NSV,919    updater: (920      value: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5> | NSV921    ) => S922  ): this;923  updateIn<924    K2: $KeyOf<V>,925    K3: $KeyOf<$ValOf<V, K2>>,926    K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,927    K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,928    S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>,929  >(930    keyPath: [K, K2, K3, K4, K5],931    updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>) => S932  ): this;933}934 935declare function isList(maybeList: mixed): boolean %checks(maybeList instanceof936  List);937declare class List<+T>938  extends IndexedCollection<T>939  mixins UpdatableInCollection<number, T>940{941  static <T>(collection?: Iterable<T>): List<T>;942 943  static of<T>(...values: T[]): List<T>;944 945  static isList: typeof isList;946 947  size: number;948 949  set<U>(index: number, value: U): List<T | U>;950  delete(index: number): this;951  remove(index: number): this;952  insert<U>(index: number, value: U): List<T | U>;953  clear(): this;954  push<U>(...values: U[]): List<T | U>;955  pop(): this;956  unshift<U>(...values: U[]): List<T | U>;957  shift(): this;958 959  update<U>(updater: (value: this) => U): U;960  update<U>(index: number, updater: (value: T) => U): List<T | U>;961  update<U>(962    index: number,963    notSetValue: U,964    updater: (value: T) => U965  ): List<T | U>;966 967  merge<U>(...collections: Iterable<U>[]): List<T | U>;968 969  setSize(size: number): this;970 971  mergeIn(keyPath: Iterable<mixed>, ...collections: Iterable<mixed>[]): this;972  mergeDeepIn(973    keyPath: Iterable<mixed>,974    ...collections: Iterable<mixed>[]975  ): this;976 977  withMutations(mutator: (mutable: this) => mixed): this;978  asMutable(): this;979  wasAltered(): boolean;980  asImmutable(): this;981 982  // Override specialized return types983 984  concat<C>(...iters: Array<Iterable<C> | C>): List<T | C>;985 986  filter(predicate: typeof Boolean): List<$NonMaybeType<T>>;987  filter(988    predicate: (value: T, index: number, iter: this) => mixed,989    context?: mixed990  ): List<T>;991 992  partition(993    predicate: (value: T, index: number, iter: this) => mixed,994    context?: mixed995  ): [this, this];996 997  map<M>(998    mapper: (value: T, index: number, iter: this) => M,999    context?: mixed1000  ): List<M>;1001 1002  flatMap<M>(1003    mapper: (value: T, index: number, iter: this) => Iterable<M>,1004    context?: mixed1005  ): List<M>;1006 1007  flatten(depth?: number): List<any>;1008  flatten(shallow?: boolean): List<any>;1009 1010  zip<A>(a: Iterable<A>, ..._: []): List<[T, A]>;1011  zip<A, B>(a: Iterable<A>, b: Iterable<B>, ..._: []): List<[T, A, B]>;1012  zip<A, B, C>(1013    a: Iterable<A>,1014    b: Iterable<B>,1015    c: Iterable<C>,1016    ..._: []1017  ): List<[T, A, B, C]>;1018  zip<A, B, C, D>(1019    a: Iterable<A>,1020    b: Iterable<B>,1021    c: Iterable<C>,1022    d: Iterable<D>,1023    ..._: []1024  ): List<[T, A, B, C, D]>;1025  zip<A, B, C, D, E>(1026    a: Iterable<A>,1027    b: Iterable<B>,1028    c: Iterable<C>,1029    d: Iterable<D>,1030    e: Iterable<E>,1031    ..._: []1032  ): List<[T, A, B, C, D, E]>;1033 1034  zipAll<A>(a: Iterable<A>, ..._: []): List<[T | void, A | void]>;1035  zipAll<A, B>(1036    a: Iterable<A>,1037    b: Iterable<B>,1038    ..._: []1039  ): List<[T | void, A | void, B | void]>;1040  zipAll<A, B, C>(1041    a: Iterable<A>,1042    b: Iterable<B>,1043    c: Iterable<C>,1044    ..._: []1045  ): List<[T | void, A | void, B | void, C | void]>;1046  zipAll<A, B, C, D>(1047    a: Iterable<A>,1048    b: Iterable<B>,1049    c: Iterable<C>,1050    d: Iterable<D>,1051    ..._: []1052  ): List<[T | void, A | void, B | void, C | void, D | void]>;1053  zipAll<A, B, C, D, E>(1054    a: Iterable<A>,1055    b: Iterable<B>,1056    c: Iterable<C>,1057    d: Iterable<D>,1058    e: Iterable<E>,1059    ..._: []1060  ): List<[T | void, A | void, B | void, C | void, D | void, E | void]>;1061 1062  zipWith<A, R>(1063    zipper: (value: T, a: A) => R,1064    a: Iterable<A>,1065    ..._: []1066  ): List<R>;1067  zipWith<A, B, R>(1068    zipper: (value: T, a: A, b: B) => R,1069    a: Iterable<A>,1070    b: Iterable<B>,1071    ..._: []1072  ): List<R>;1073  zipWith<A, B, C, R>(1074    zipper: (value: T, a: A, b: B, c: C) => R,1075    a: Iterable<A>,1076    b: Iterable<B>,1077    c: Iterable<C>,1078    ..._: []1079  ): List<R>;1080  zipWith<A, B, C, D, R>(1081    zipper: (value: T, a: A, b: B, c: C, d: D) => R,1082    a: Iterable<A>,1083    b: Iterable<B>,1084    c: Iterable<C>,1085    d: Iterable<D>,1086    ..._: []1087  ): List<R>;1088  zipWith<A, B, C, D, E, R>(1089    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,1090    a: Iterable<A>,1091    b: Iterable<B>,1092    c: Iterable<C>,1093    d: Iterable<D>,1094    e: Iterable<E>,1095    ..._: []1096  ): List<R>;1097}1098 1099declare function isMap(maybeMap: mixed): boolean %checks(maybeMap instanceof1100  Map);1101declare class Map<K, +V>1102  extends KeyedCollection<K, V>1103  mixins UpdatableInCollection<K, V>1104{1105  static <K, V>(values?: Iterable<[K, V]> | PlainObjInput<K, V>): Map<K, V>;1106 1107  static isMap: typeof isMap;1108 1109  size: number;1110 1111  set<K_, V_>(key: K_, value: V_): Map<K | K_, V | V_>;1112  delete(key: K): this;1113  remove(key: K): this;1114  clear(): this;1115 1116  deleteAll(keys: Iterable<K>): Map<K, V>;1117  removeAll(keys: Iterable<K>): Map<K, V>;1118 1119  update<U>(updater: (value: this) => U): U;1120  update<V_>(key: K, updater: (value: V) => V_): Map<K, V | V_>;1121  update<V_>(1122    key: K,1123    notSetValue: V_,1124    updater: (value: V) => V_1125  ): Map<K, V | V_>;1126 1127  merge<K_, V_>(1128    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]1129  ): Map<K | K_, V | V_>;1130  concat<K_, V_>(1131    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]1132  ): Map<K | K_, V | V_>;1133 1134  mergeWith<K_, W, X>(1135    merger: (oldVal: V, newVal: W, key: K) => X,1136    ...collections: (Iterable<[K_, W]> | PlainObjInput<K_, W>)[]1137  ): Map<K | K_, V | W | X>;1138 1139  mergeDeep<K_, V_>(1140    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]1141  ): Map<K | K_, V | V_>;1142 1143  mergeDeepWith<K_, V_>(1144    merger: (oldVal: any, newVal: any, key: any) => mixed,1145    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]1146  ): Map<K | K_, V | V_>;1147 1148  mergeIn(1149    keyPath: Iterable<mixed>,1150    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]1151  ): this;1152  mergeDeepIn(1153    keyPath: Iterable<mixed>,1154    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]1155  ): this;1156 1157  withMutations(mutator: (mutable: this) => mixed): this;1158  asMutable(): this;1159  wasAltered(): boolean;1160  asImmutable(): this;1161 1162  // Override specialized return types1163 1164  flip(): Map<V, K>;1165 1166  filter(predicate: typeof Boolean): Map<K, $NonMaybeType<V>>;1167  filter(1168    predicate: (value: V, key: K, iter: this) => mixed,1169    context?: mixed1170  ): Map<K, V>;1171 1172  partition(1173    predicate: (value: V, key: K, iter: this) => mixed,1174    context?: mixed1175  ): [this, this];1176 1177  map<M>(1178    mapper: (value: V, key: K, iter: this) => M,1179    context?: mixed1180  ): Map<K, M>;1181 1182  mapKeys<M>(1183    mapper: (key: K, value: V, iter: this) => M,1184    context?: mixed1185  ): Map<M, V>;1186 1187  mapEntries<KM, VM>(1188    mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],1189    context?: mixed1190  ): Map<KM, VM>;1191 1192  flatMap<KM, VM>(1193    mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,1194    context?: mixed1195  ): Map<KM, VM>;1196 1197  flatten(depth?: number): Map<any, any>;1198  flatten(shallow?: boolean): Map<any, any>;1199}1200 

Showing the first 1,200 of 2415 lines. Download the file for the rest.