Codibre/fluent-iterable

import { AnyIterable, Mapper } from 'augmentative-iterable';
import { FluentAsyncIterable, FluentIterable } from '../base';

export interface CombineFunction<T> {
  /**
   * Join the iterable with another one, returning a new iterable with a NxN combination
   * @param iterable The iterable to be combined
   */
  <U>(iterable: Iterable<U>): FluentIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A mapper that returns the key map value from the left iterable
   * @param keyB A mapper that returns the key map value from the right iterable
   */
  <U, K>(
    iterable: Iterable<U>,
    keyA: Mapper<T, K>,
    keyB: Mapper<U, K>,
  ): FluentIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A property name with value will be used as for comparison with the key of the second iterable
   * @param keyB A mapper that returns the key map value from the right iterable
   */
  <U, K>(
    iterable: Iterable<U>,
    keyA: keyof T,
    keyB: Mapper<U, K>,
  ): FluentIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A mapper that returns the key map value from the left iterable
   * @param keyB A property name with value will be used as for comparison with the key of the first iterable
   */
  <U, K>(
    iterable: Iterable<U>,
    keyA: Mapper<T, K>,
    keyB: keyof U,
  ): FluentIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A property name with value will be used as for comparison with the key of the second iterable
   * @param keyB A property name with value will be used as for comparison with the key of the first iterable
   */
  <U>(
    iterable: Iterable<U>,
    keyA: keyof T,
    keyB: keyof U,
  ): FluentIterable<[T, U]>;
}

export interface AsyncCombineFunction<T> {
  /**
   * Join the iterable with an async one, returning a new async iterable with a NxN combination
   * @param iterable The iterable to be combined
   */
  <U>(iterable: AnyIterable<U>): FluentAsyncIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new async iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A mapper that returns the key map value from the left iterable
   * @param keyB A mapper that returns the key map value from the right iterable
   */
  <U, K>(
    iterable: AnyIterable<U>,
    keyA: Mapper<T, K>,
    keyB: Mapper<U, K>,
  ): FluentAsyncIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new async iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A property name with value will be used as for comparison with the key of the second iterable
   * @param keyB A mapper that returns the key map value from the right iterable
   */
  <U, K>(
    iterable: AnyIterable<U>,
    keyA: keyof T,
    keyB: Mapper<U, K>,
  ): FluentAsyncIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new async iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A mapper that returns the key map value from the left iterable
   * @param keyB A property name with value will be used as for comparison with the key of the first iterable
   */
  <U, K>(
    iterable: AnyIterable<U>,
    keyA: Mapper<T, K>,
    keyB: keyof U,
  ): FluentAsyncIterable<[T, U]>;

  /**
   * Join the iterable with another one, returning a new async iterable with the inner matching combinations
   * @param iterable The right iterable to be combined
   * @param keyA A property name with value will be used as for comparison with the key of the second iterable
   * @param keyB A property name with value will be used as for comparison with the key of the first iterable
   */
  <U>(
    iterable: AnyIterable<U>,
    keyA: keyof T,
    keyB: keyof U,
  ): FluentAsyncIterable<[T, U]>;
}