src/static.ts
import { DONE, Seq } from "./Seq"import { constant, identity, first } from "@tdreyno/figment" export const fromArray = <T>(data: T[]) => new Seq(() => { const len = data.length let i = 0 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion return (): typeof DONE | T => (i >= len ? DONE : data[i++]!) }) export const iterate = <T>(fn: (current: T) => T, start: T) => new Seq(() => { let counter = 0 let previous: T = start return (): T => { if (counter++ === 0) { return start } previous = fn(previous) counter++ return previous } }) export const fib = () => iterate(([a, b]) => [b, a + b], [0, 1]).map(first) export const of = <T>(head: T, ...values: T[]) => fromArray([head, ...values]) export const range = (start: number, end: number, step = 1) => new Seq(() => { const isForwards = start < end let i = 0 return isForwardsSimilar blocks of code found in 2 locations. Consider refactoring. ? (): typeof DONE | number => { const num = start + i if (num > end) { return DONE } i += step return num }Similar blocks of code found in 2 locations. Consider refactoring. : (): typeof DONE | number => { const num = start - i if (num < end) { return DONE } i += step return num } }) export const cycle = <T>(items: T[]) => new Seq(() => { const len = items.length let i = 0 return (): T => items[i++ % len] }) export const repeatedly = <T>(value: () => T, times = Infinity) => new Seq(() => { let index = 0 return (): typeof DONE | T => (index++ + 1 > times ? DONE : value()) }) export const repeat = <T>(value: T, times = Infinity) => repeatedly(constant(value), times) export const empty = () => fromArray([]) export const infinite = () => range(0, Infinity) export const zipWith = <T1, T2, T3>(Similar blocks of code found in 2 locations. Consider refactoring. fn: ( [result1, result2]: [T1, T2] | [T1, undefined] | [undefined, T2], index: number, ) => T3, seq1: Seq<T1>, seq2: Seq<T2>,) => seq1.zipWith(fn, seq2) export const zip = <T1, T2>(seq1: Seq<T1>, seq2: Seq<T2>) => zipWith(identity, seq1, seq2) export const zip3With = <T1, T2, T3, T4>(Similar blocks of code found in 2 locations. Consider refactoring. fn: ( [result1, result2, resul3]: | [T1, T2, T3] | [T1, undefined, undefined] | [T1, T2, undefined] | [T1, undefined, T3] | [undefined, T2, undefined] | [undefined, T2, T3] | [undefined, undefined, T3], index: number, ) => T4, seq1: Seq<T1>, seq2: Seq<T2>, seq3: Seq<T3>,) => seq1.zip2With(fn, seq2, seq3) export const zip3 = <T1, T2, T3>(seq1: Seq<T1>, seq2: Seq<T2>, seq3: Seq<T3>) => zip3With(identity, seq1, seq2, seq3) Similar blocks of code found in 2 locations. Consider refactoring.export const concat = <T>(head: Seq<T>, ...remaining: Array<Seq<T>>) => head.concat(...remaining) Similar blocks of code found in 2 locations. Consider refactoring.export const interleave = <T>(head: Seq<T>, ...remaining: Array<Seq<T>>) => head.interleave(...remaining)