Array.ts

// This file is just to keep track of not-included array methods

interface Array implements ~ISyncCollection {
  // Mutates collection
  pop() : Object;
  shift() : Object;
  push(...value : Object) : Number;
  unshift(...value : Object) : Number;
  splice(start : Number, deleteCount : Number, ...value : Object = null) : Array;

  // can be useful async
  findIndex(test : TestIterator) : Number;
  indexOf(search : Object, fromIndex : Number = 0) : Number;
}

helpers.ts

declare var Value<T> = T | Promise<T>;

interface Iterator<T> {
  (entry : T, index : Number, collection : ICollection<T>) : void;
}

interface TestIterator<T> {
  (entry : T, index : Number, collection : ICollection<T>) : Boolean;
}

interface MapIterator<T, Y> {
  (entry : T, index : Number, collection : ICollection<T>) : Y;
}

interface ReduceIterator<T, Y> {
  (result : Y, entry : T, index : Number, collection : ICollection<T>) : Y;
}

interface CompareIterator<T> {
  (a : T, b : T) : Number;
}

IAsyncCollection.ts

interface IAsyncCollection<T> implements ICollection<T> {
  // Returns subinterface
  concat(...collection : ICollection) : IAsyncCollection; // Waits for 1st collection to finish to concat next one
  filter(test : TestIterator<T>) : IAsyncCollection<T>;
  map(iterator : MapIterator<T, Y>) : IAsyncCollection<Y>;
  slice(start : Number, end : Number = this.length) : IAsyncCollection<T>;
  flatten() : IAsyncCollection<T>;

  // Returns value
  entries() : Generator<Promise<T>>;
  keys() : Generator<Promise<Number>>;
  values() : Generator<Promise<Array<Number, T>>>;
  every(iterator : Iterator<T>) : Promise<Boolean>;
  includes(search : T, fromIndex : Number = 0) : Promise<Boolean>;
  join(separator : String = ',') : Promise<String>;
  reduce(iteartor : ReduceIterator<T, Y>, initialValue : Y = null) : Promise<Y>;
  some(test : TestIterator<T>) : Promise<Boolean>;
  length : Promise<Number>;

  // extras
  flatten() : IAsyncCollection<T>;
  skipUntil(test : TestIterator<T>) : IAsyncCollection<T>;
  takeUntil(test : TestIterator<T>) : IAsyncCollection<T>;
  skip(count : Number) : IAsyncCollection<T>;
  take(count : Number) : IAsyncCollection<T>;
  zip(... collection : ICollection) : IAsyncCollection;
  single() : Promise<T>;
  first() : Promise<T>;
  last() : Promise<T>;

  // Async only
  accumulate(iterator : ReduceIterator<T, Y>) : IAsyncCollection<Y>; // Like reduce but returns for each iteration
  delay(milliseconds : Number) : IAsyncCollection<T>;
}

ICollection.ts

interface ICollection<T> {
  // Same for all collections
  forEach(iterator : Iterator<T>) : void; // alias subscribe

  // Returns subinterface
  concat(... collection : ICollection) : ICollection;
  filter(test : TestIterator<T>) : ICollection<T>;
  map(iterator : MapIterator<T, Y>) : ICollection<Y>;
  slice(start : Number, end : Number = this.length) : ICollection<T>;

  // Returns value
  entries() : Generator<Value<T>>;
  keys() : Generator<Value<Number>>;
  values() : Generator<Value<Array<Number, T>>>;
  every(iterator : Iterator<T>) : Value<Boolean>;
  includes(search : T, fromIndex : Number = 0) : Value<Boolean>;
  join(separator : String = ',') : Value<String>;
  reduce(iteartor : ReduceIterator<T, Y>, initialValue : Y = null) : Value<Y>;
  some(test : TestIterator<T>) : Value<Boolean>;
  length : Value<Number>;

  // extras
  flatten() : ICollection<T>;
  skipUntil(test : TestIterator<T>) : ICollection<T>;
  takeUntil(test : TestIterator<T>) : ICollection<T>;
  skip(count : Number) : ICollection<T>;
  take(count : Number) : ICollection<T>;
  zip(... collection : ICollection) : ICollection; // zip[1,2],[3,4],[5,6]) = [[1,3,5],[2,4,6]];
  single() : Value<T>; // throws error if length !== 1
  first() : Value<T>; // immutable shift
  last() : Value<T>; // immutable pop

  // Conversions
  toArray() : ISyncCollection<T>;
  toStream() : IAsyncCollection<T>;
}

ISyncCollection.ts

interface ISyncCollection<T> implements ICollection<T> {
  // Returns subinterface
  concat(... collection : ISyncCollection) : ISyncCollection;
  filter(test : TestIterator<T>) : ISyncCollection<T>;
  map(iterator : MapIterator<T, Y>) : ISyncCollection<Y>;
  slice(start : Number, end : Number = this.length) : ISyncCollection<T>;

  // Returns value
  entries() : Generator<T>;
  keys() : Generator<Number>;
  values() : Generator<Array<Number, T>>;
  every(iterator : Iterator<T>) : Boolean;
  includes(search : T, fromIndex : Number = 0) : Boolean;
  join(separator : String = ',') : String;
  reduce(iteartor : ReduceIterator<T, Y>, initialValue : Y = null) : Y;
  some(test : TestIterator<T>) : Boolean;
  length : Number;

  // extras
  flatten() : ISyncCollection<T>;
  skipUntil(test : TestIterator<T>) : ISyncCollection<T>;
  takeUntil(test : TestIterator<T>) : ISyncCollection<T>;
  skip(count : Number) : ISyncCollection<T>;
  take(count : Number) : ISyncCollection<T>;
  zip(... collection : ICollection) : ICollection;
  single() : T;
  first() : T;
  last() : T;

  // Sync only
  fill(value : Object, start : Number = 0, end : Number = this.length) : void;
  lastIndexOf(search : Object, fromIndex : Number = this.length - 1) : Number;
  reduceRight(iteartor : ReduceIterator, initialValue : Object = null) : Object;
  reverse() : ISyncCollection;
  sort(compare : CompareIterator = null) : ISyncCollection;
}