nodef/extra-lists

File index.ts has 460 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 maxEntry<K, V, W=V>(x: Lists<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 minEntry<K, V, W=V>(x: Lists<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 min<K, V, W=V>(x: Lists<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: Lists<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

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

Open

export function isEqual<K, V, W=V>(x: Lists<K, V>, y: Lists<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: Lists<K, V>, y: Lists<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: Lists<K, V>, y: Lists<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: Lists<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: Lists<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: Lists<K, V>, v: V, fc: CompareFunction<V|W> | null=null, fm: MapFunction<K, V, V|W> | null=null): boolean {
  if (!fc && !fm) return x[1].includes(v);
  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: Lists<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: Lists<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: Lists<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: Lists<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 set<K, V>(x: Lists<K, V>, k: K, v: V): Lists<K, V> {
  return set$(shallowClone(x), k, v);
}

• Read up
  Read up

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

Open

export function search<K, V>(x: Lists<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: Lists<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 swap<K, V>(x: Lists<K, V>, k: K, l: K): Lists<K, V> {
  return swap$(shallowClone(x), k, l);
}

• Read up
  Read up

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

Open

export function take$<K, V>(x: Lists<K, V>, n: number=1): Lists<K, V> {
  return slice$(x, 0, n);
}

• Read up
  Read up