nodef/extra-ilists

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 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 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

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";

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 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

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

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 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 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 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 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 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 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 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 values<K, V>(x: ILists<K, V>): Iterable<V> {
  return x[1];
}

• Read up
  Read up