nodef/extra-ilists

File index.ts has 313 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import {
  IDENTITY,
  COMPARE,
} from "extra-function";
import * as xiterable from "extra-iterable";

Function flatTo$ has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

function flatTo$<K>(a: Map<K, any>, x: ILists<K, any>, n: number, fm: MapFunction<K, any, any>, ft: TestFunction<K, any>): Map<K, any> {

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function minEntry<K, V, W=V>(x: ILists<K, V>, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): [K, V] {
  return rangeEntries(x, fc, fm)[0];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function maxEntry<K, V, W=V>(x: ILists<K, V>, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): [K, V] {
  return rangeEntries(x, fc, fm)[1];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function min<K, V, W=V>(x: ILists<K, V>, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): V {
  return rangeEntries(x, fc, fm)[0][1];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function max<K, V, W=V>(x: ILists<K, V>, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): V {
  return rangeEntries(x, fc, fm)[1][1];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function take<K, V>(x: ILists<K, V>, n: number=1): ILists<K, V> {
  var ks = xiterable.take(keys(x), n);
  var vs = xiterable.take(values(x), n);
  return [ks, vs];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function drop<K, V>(x: ILists<K, V>, n: number=1): ILists<K, V> {
  var ks = xiterable.drop(keys(x), n);
  var vs = xiterable.drop(values(x), n);
  return [ks, vs];
}

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

export function isEqual<K, V, W=V>(x: ILists<K, V>, y: ILists<K, V>, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): boolean {
  return compare(x, y, fc, fm)===0;
}

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

export function compare<K, V, W=V>(x: ILists<K, V>, y: ILists<K, V>, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): number {
  return xmap.compare(xmap.fromLists(x), xmap.fromLists(y), fc, fm as any);
}

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

export function hasSubset<K, V, W=V>(x: ILists<K, V>, y: ILists<K, V>, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): boolean {
  return xmap.hasSubset(xmap.fromLists(x), xmap.fromLists(y), fc, fm as any);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function searchAll<K, V>(x: ILists<K, V>, ft: TestFunction<K, V>): Iterable<K> {
  return xentries.searchAll(entries(x), ft as any);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function findAll<K, V>(x: ILists<K, V>, ft: TestFunction<K, V>): Iterable<V> {
  return xentries.findAll(entries(x), ft as any);
}

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

export function hasValue<K, V, W=V>(x: ILists<K, V>, v: V, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): boolean {
  return searchValue(x, v, fc, fm)!==undefined;
}

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

export function searchValue<K, V, W=V>(x: ILists<K, V>, v: V, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): K {
  return xentries.searchValue(entries(x), v, fc, fm as any);
}

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

export function searchValueAll<K, V, W=V>(x: ILists<K, V>, v: V, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): Iterable<K> {
  return xentries.searchValueAll(entries(x), v, fc, fm as any);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function randomValue<K, V>(x: ILists<K, V>, fr: ReadFunction<number>=Math.random): V {
  return xarray.randomValue([...values(x)], fr);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function randomKey<K, V>(x: ILists<K, V>, fr: ReadFunction<number>=Math.random): K {
  return xarray.randomValue([...keys(x)], fr);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function find<K, V>(x: ILists<K, V>, ft: TestFunction<K, V>): V {
  return xentries.find(entries(x), ft as any);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function search<K, V>(x: ILists<K, V>, ft: TestFunction<K, V>): K {
  return xentries.search(entries(x), ft as any);
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function keys<K, V>(x: ILists<K, V>): Iterable<K> {
  return x[0];
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export function values<K, V>(x: ILists<K, V>): Iterable<V> {
  return x[1];
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

export function intersection<K, V>(x: ILists<K, V>, y: ILists<K, V>, fc: CombineFunction<V> | null=null): ILists<K, V> {
  var a = xmap.intersection(new Map(entries(x)), entries(y), fc);
  return [a.keys(), a.values()];
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

export function union<K, V>(x: ILists<K, V>, y: ILists<K, V>, fc: CombineFunction<V> | null=null): ILists<K, V> {
  var a = xmap.union(entries(x), entries(y), fc);
  return [a.keys(), a.values()];
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

export function partitionAs<K, V, W=V>(x: ILists<K, V>, fm: MapFunction<K, V, V|W> | null=null): Map<V|W, ILists<K, V>> {
  var fm = fm || IDENTITY;
  var a  = new Map();
  for (var [k, v] of entries(x)) {
    var v1 = fm(v, k, x);

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

export function countAs<K, V, W=V>(x: ILists<K, V>, fm: MapFunction<K, V, V|W> | null=null): Map<V|W, number> {
  return xentries.countAs(entries(x), fm as any);
}

• Read up
  Read up