repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
syrflover/iterator-helper
|
src/methods/nub.ts
|
import { getLogger } from '../logger.ts';
import { nubBy } from './nubBy.ts';
const logger = await getLogger('methods/nub');
export function nub<T>(iter: AsyncIterable<T>): AsyncIterable<T> {
logger.trace('nub()');
return nubBy<T>((a, b) => a === b, iter);
}
|
syrflover/iterator-helper
|
src/methods/filter_test.ts
|
<reponame>syrflover/iterator-helper
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('filter() is even', async () => {
const a = iterator([1, 2, 3, 4, 5, 6]);
const actual: number[] = [];
const expected = [2, 4, 6];
for await (const _ of a.filter((e) => e % 2 === 0)) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/types/functions/mod.ts
|
export * from './compare.ts';
export * from './equal.ts';
export * from './fold.ts';
export * from './forEach.ts';
export * from './key.ts';
export * from './map.ts';
export * from './predicate.ts';
export * from './scan.ts';
|
syrflover/iterator-helper
|
bench/filter.ts
|
import { BenchmarkTimer, BenchmarkDefinition } from 'https://deno.land/std/testing/bench.ts';
import { iterator } from '../mod.ts';
async function* range_async(end: number) {
let i = 0;
const e = end + 1;
while (i < e) {
yield i;
i++;
}
}
function* range_sync(end: number) {
let i = 0;
const e = end + 1;
while (i < e) {
yield i;
i++;
}
}
export function filter_bench_0(): BenchmarkDefinition {
return {
name: 'Iterator [0..1000].filter((e) => e % 2 === 0)',
runs: 400,
func: async (b: BenchmarkTimer) => {
const iter = iterator(range_async(1000));
b.start();
for await (const _ of iter.filter((e) => e % 2 === 0)) {
// do nothing
}
b.stop();
},
};
}
export function filter_bench_1(): BenchmarkDefinition {
return {
name: 'Iterator [0..100000].filter((e) => e % 2 === 0)',
runs: 400,
func: async (b: BenchmarkTimer) => {
const iter = iterator(range_async(100000));
b.start();
for await (const _ of iter.filter((e) => e % 2 === 0)) {
// do nothing
}
b.stop();
},
};
}
export function filter_bench_2(): BenchmarkDefinition {
return {
name: 'Array [0..1000].filter((e) => e % 2 === 0)',
runs: 400,
func: (b: BenchmarkTimer) => {
const array = Array.from(range_sync(1000));
b.start();
for (const _ of array.filter((e) => e % 2 === 0)) {
// do nothing
}
b.stop();
},
};
}
export function filter_bench_3(): BenchmarkDefinition {
return {
name: 'Array [0..100000].filter((e) => e % 2 === 0)',
runs: 400,
func: (b: BenchmarkTimer) => {
const array = Array.from(range_sync(100000));
b.start();
for (const _ of array.filter((e) => e % 2 === 0)) {
// do nothing
}
b.stop();
},
};
}
|
syrflover/iterator-helper
|
deno/methods/forEach.ts
|
import type { ForEachFn } from "../types/functions/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
async function _for_each_impl_fn<T>(
fn: ForEachFn<T>,
iter: AsyncIterable<T>,
): Promise<void> {
for await (const elem of iter) {
await fn(elem);
}
}
export interface ForEach {
<T>(fn: ForEachFn<T>, iter: AsyncIterable<T>): Promise<void>;
<T>(fn: ForEachFn<T>): (iter: AsyncIterable<T>) => Promise<void>;
}
export const forEach: ForEach = _curry(_for_each_impl_fn);
|
syrflover/iterator-helper
|
src/types/functions/forEach.ts
|
<filename>src/types/functions/forEach.ts
export type ForEachFn<T> = (elem: T) => void | Promise<void>;
|
syrflover/iterator-helper
|
src/methods/flatMap_test.ts
|
<reponame>syrflover/iterator-helper<gh_stars>1-10
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test(`flatMap() [\`it's Sunny in\`, '', 'California'] split(' ')`, async () => {
const a = iterator([`it's Sunny in`, '', 'California']);
const actual: string[] = [];
const expected = [`it's`, 'Sunny', 'in', '', 'California'];
for await (const _ of a.flatMap((e) => e.split(' '))) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('flatMap() [[1,2,3],[4,5,6]] * 2', async () => {
const a = iterator([
[1, 2, 3],
[4, 5, 6],
]);
const actual: (number | number[])[] = [];
const expected = [2, 4, 6, 8, 10, 12];
for await (const _ of a.flatMap((e) => e.map((ee) => ee * 2))) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/lib/iterable/append_test.ts
|
<gh_stars>1-10
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { append } from './mod.ts';
Deno.test('append(1, [0])', async () => {
const actual: number[] = [];
const expected = [0, 1];
for await (const _ of append(1, [0])) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/maxByKey.ts
|
import type { CompareFn, KeyFn } from "../types/functions/mod.ts";
import { maxBy as compare_maxBy } from "../lib/compare/mod.ts";
import { next_async } from "../lib/iterable/mod.ts";
import { _curry, Curry2 } from "../lib/utils/mod.ts";
import { fold } from "./fold.ts";
async function _max_by_key_impl_fn<T, K>(
keyFn: KeyFn<T, K>,
cmpFn: CompareFn<K>,
iter: AsyncIterable<T>,
): Promise<T | undefined> {
const { done, value } = await next_async(iter);
if (done) {
return;
}
return fold(
async (acc, e) => compare_maxBy(keyFn, cmpFn, acc, e),
value,
iter,
);
}
export interface MaxByKey {
<T, K>(
keyFn: KeyFn<T, K>,
cmpFn: CompareFn<K>,
iter: AsyncIterable<T>,
): Promise<T | undefined>;
<T, K>(
keyFn: KeyFn<T, K>,
cmpFn: CompareFn<K>,
): (iter: AsyncIterable<T>) => Promise<T | undefined>;
<T, K>(
keyFn: KeyFn<T, K>,
): Curry2<CompareFn<K>, AsyncIterable<T>, Promise<T | undefined>>;
}
export const maxByKey: MaxByKey = _curry(_max_by_key_impl_fn);
|
syrflover/iterator-helper
|
src/logger.ts
|
<gh_stars>1-10
// import * as log from 'https://deno.land/std/log/mod.ts';
import { Logger, LogRecord } from 'https://deno.land/std/log/logger.ts';
import { LogLevels, getLevelByName } from 'https://deno.land/std/log/levels.ts';
import { BaseHandler } from 'https://deno.land/std/log/handlers.ts';
import { blue, cyan, green, yellow, red, bold } from 'https://deno.land/std/fmt/colors.ts';
import type { LevelName } from 'https://deno.land/std/log/levels.ts';
/* const getLevelByName = (levelName: string) => {
switch (levelName) {
case 'NONE':
return -1;
case 'TRACE':
return 5;
default:
return getLevelByName_(levelName );
}
}; */
class LogHandler extends BaseHandler {
constructor(levelName: LevelName) {
super(levelName);
this.level = getLevelByName(levelName);
this.levelName = levelName;
}
public handle(logRecord: LogRecord): void {
if (this.level === -1) {
return;
}
const msg = this.format(logRecord);
return this.log(msg);
}
public format(logRecord: LogRecord): string {
const { datetime, level, msg, args } = logRecord;
const time = datetime.toISOString();
const stringify = (v: any) => {
try {
const str = JSON.stringify(v);
return str.replace(/(^"|"$)/g, '');
} catch {
return v;
}
};
const to = (t: string, lv: string, m: string, a: unknown[]) => `${t} ${lv} ${m} ${a.map((e) => stringify(e)).join(' ')}`;
switch (level) {
case LogLevels.NOTSET: // trace
return to(`[${time}]`, blue('[TRACE]'), msg, args);
case LogLevels.DEBUG:
return to(`[${time}]`, cyan('[DEBUG]'), msg, args);
case LogLevels.INFO:
return to(`[${time}]`, green('[INFO]'), msg, args);
case LogLevels.WARNING:
return to(`[${time}]`, yellow('[WARNING]'), msg, args);
case LogLevels.ERROR:
return to(`[${time}]`, red('[ERROR]'), msg, args);
case LogLevels.CRITICAL:
return to(`[${time}]`, bold(red('[CRITICAL]')), msg, args);
default:
return '';
}
}
public log(msg: string): void {
if (msg.length > 1) {
/* eslint-disable-next-line */
console.log(msg);
}
}
}
// const logEnable = Deno.args.some((e) => e.includes('ITER_HELPER_LOG'));
// const LOG_LEVEL = logEnable ? 'NOTSET' : 'ERROR';
export async function getLogger(label: string) {
const toLogLevel = (s: string): LevelName => {
switch (s) {
case 'TRACE':
return 'NOTSET';
case '':
case 'NONE':
return 'ERROR';
default:
return s as LevelName;
}
};
const isEnvGranted = (await Deno.permissions.query({ name: 'env' })).state === 'granted';
const LOG_LEVEL_ = isEnvGranted ? Deno.env.get('LOG_LEVEL')?.trim().toUpperCase() ?? 'ERROR' : 'ERROR';
const LOG_LEVEL = toLogLevel(LOG_LEVEL_);
const logger = new Logger('logger', LOG_LEVEL, { handlers: [new LogHandler(LOG_LEVEL)] });
return {
trace: (msg: string, ...args: unknown[]) => (logger as any)._log(LogLevels.NOTSET, label, msg, ...args),
debug: (msg: string, ...args: unknown[]) => (logger as any)._log(LogLevels.DEBUG, label, msg, ...args),
info: (msg: string, ...args: unknown[]) => (logger as any)._log(LogLevels.INFO, label, msg, ...args),
warning: (msg: string, ...args: unknown[]) => (logger as any)._log(LogLevels.WARNING, label, msg, ...args),
error: (msg: string, ...args: unknown[]) => (logger as any)._log(LogLevels.ERROR, label, msg, ...args),
critical: (msg: string, ...args: unknown[]) => (logger as any)._log(LogLevels.CRITICAL, label, msg, ...args),
};
}
|
syrflover/iterator-helper
|
src/methods/partition_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('partition() even', async () => {
const a = iterator([1, 2, 3, Promise.resolve(4), 5]);
const actual_left: number[] = [];
const expected_left = [2, 4];
const actual_right: number[] = [];
const expected_right = [1, 3, 5];
const [left, right] = await a.partition((e) => e % 2 === 0);
for await (const _ of left) {
actual_left.push(_);
}
for await (const _ of right) {
actual_right.push(_);
}
assertEquals(actual_left, expected_left);
assertEquals(actual_right, expected_right);
});
|
syrflover/iterator-helper
|
deno/methods/collect.ts
|
import { fold } from "./fold.ts";
export function collect<T>(iter: AsyncIterable<T>): Promise<T[]> {
return fold((acc: T[], e: T) => [...acc, e], [] as T[], iter);
}
|
syrflover/iterator-helper
|
src/methods/fold_test.ts
|
<reponame>syrflover/iterator-helper
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('fold() sum', async () => {
const a = iterator([1, 2, 3, Promise.resolve(4), 5]);
const actual_elements: number[] = [];
const expected_elements = [1, 2, 3, 4, 5];
const actual_accumulator_without_result: number[] = [];
const expected_accumulator_without_result = [1, 2, 4, 7, 11];
const actual_result = await a.fold(Promise.resolve(1), (acc, e) => {
actual_elements.push(e);
actual_accumulator_without_result.push(acc);
return acc + e;
});
const expected_result = 16;
assertEquals(actual_elements, expected_elements);
assertEquals(actual_accumulator_without_result, expected_accumulator_without_result);
assertEquals(actual_result, expected_result);
});
Deno.test('fold() `${acc}${e}`', async () => {
const a = iterator([1, 2, 3, Promise.resolve(4), 5]);
const actual_elements: number[] = [];
const expected_elements = [1, 2, 3, 4, 5];
const actual_accumulator_without_result: string[] = [];
const expected_accumulator_without_result = ['1', '11', '112', '1123', '11234'];
const actual_result = await a.fold('1', (acc, e) => {
actual_elements.push(e);
actual_accumulator_without_result.push(acc);
return `${acc}${e}`;
});
const expected_result = '112345';
assertEquals(actual_elements, expected_elements);
assertEquals(actual_accumulator_without_result, expected_accumulator_without_result);
assertEquals(actual_result, expected_result);
});
|
syrflover/iterator-helper
|
deno/lib/compare/mod.ts
|
<gh_stars>1-10
export * from './compare.ts';
export * from './maxBy.ts';
export * from './max.ts';
export * from './minBy.ts';
export * from './min.ts';
|
syrflover/iterator-helper
|
src/methods/head.ts
|
<reponame>syrflover/iterator-helper<filename>src/methods/head.ts
import { getLogger } from '../logger.ts';
import { next_async } from '../lib/iterable/mod.ts';
const logger = await getLogger('methods/head');
async function _head_impl_fn<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
logger.trace('head()');
const { done, value } = await next_async(iter);
logger.debug('done =', done);
logger.debug('value =', value);
if (done) {
return;
}
return value;
}
export function head<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
return _head_impl_fn(iter);
}
|
syrflover/iterator-helper
|
scripts/test.ts
|
<filename>scripts/test.ts
/* eslint-disable */
import { $ } from '../src/lib/utils/mod.ts';
import { collect } from '../src/methods/mod.ts';
async function* getFileNamesInDirectory(dir: string): AsyncIterable<string> {
const excludes = ['src/playground.ts', 'src/logger.ts', 'src/iterator.ts'];
const files = Deno.readDir(dir);
for await (const file of files) {
try {
if (excludes.includes(`${dir}/${file.name}`)) {
continue;
}
const stat = await Deno.stat(`${dir}/${file.name}`);
if (stat.isFile) {
yield `${dir}/${file.name}`;
} else if (stat.isDirectory) {
yield* getFileNamesInDirectory(`${dir}/${file.name}`);
}
} catch (error) {
console.error(file.name, error);
}
}
}
async function filterSourceFiles(files: string[]) {
// const excludes = ['src/types/']; // [/src\/types\/[a-z]+\.ts/i, /src\/types\/functions\/[a-z]+\.ts/i];
return files.filter((file) => {
if (file.endsWith('mod.ts')) {
return false;
}
if (file.endsWith('_test.ts')) {
return false;
}
// const isExclude = excludes.some((exclude) => exclude.test(file));
if (file.startsWith('src/types/')) {
return false;
}
return true;
});
}
function hasAllTestFiles(files: string[], testFiles: string[]) {
l: for (const file of files) {
const withTestExt = file.replace(/\.ts$/, '_test.ts');
for (const testFile of testFiles) {
if (testFile.includes(withTestExt)) {
continue l;
}
}
console.error(`Not Found Test File of "${file}"`);
Deno.exit(1);
}
}
async function runTest(testFiles: string[]) {
const reload = Deno.args.includes('reload') ? ' --reload' : '';
const testOpts = `--unstable${reload} --config tsconfig.test.json ${testFiles.join(' ')}`;
const test = Deno.run({
cmd: `deno test ${testOpts}`.split(' '),
});
const { code } = await test.status();
Deno.exit(code);
}
async function main() {
const files = await $(getFileNamesInDirectory('src'), collect);
const sourceFiles = await filterSourceFiles(files);
const testFiles = files.filter((sourceFile) => sourceFile.endsWith('_test.ts'));
hasAllTestFiles(sourceFiles, testFiles);
await runTest(testFiles);
}
main();
|
syrflover/iterator-helper
|
mod.ts
|
export * from './deno/mod.ts';
|
syrflover/iterator-helper
|
deno/methods/fold.ts
|
import type { FoldFn } from "../types/functions/mod.ts";
import { _curry, Curry2 } from "../lib/utils/mod.ts";
async function _fold_impl_fn<A, B>(
fn: FoldFn<A, B>,
init: B | Promise<B>,
iter: AsyncIterable<A>,
): Promise<B> {
let acc = await init;
for await (const elem of iter) {
acc = await fn(acc, elem);
}
return acc;
}
export interface Fold {
<A, B>(
fn: FoldFn<A, B>,
init: B | Promise<B>,
iter: AsyncIterable<A>,
): Promise<B>;
<A, B>(
fn: FoldFn<A, B>,
init: B | Promise<B>,
): (iter: AsyncIterable<A>) => Promise<B>;
<A, B>(
fn: FoldFn<A, B>,
): Curry2<B | Promise<B>, AsyncIterable<A>, Promise<B>>;
}
// (b -> a -> b) -> b -> t a -> b
export const fold: Fold = _curry(_fold_impl_fn);
|
syrflover/iterator-helper
|
src/methods/takeWhile_test.ts
|
<filename>src/methods/takeWhile_test.ts
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('takeWhile(x < 3, [1,2,3,4,1,2,3,4]) == [1,2]', async () => {
const a = iterator([1, 2, 3, 4, 1, 2, 3, 4]);
const actual: number[] = [];
const expected = [1, 2];
const it = a.takeWhile((e) => e < 3);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('takeWhile(e < 9, [1,2,3]) == [1,2,3]', async () => {
const a = iterator([1, 2, 3]);
const actual: number[] = [];
const expected = [1, 2, 3];
const it = a.takeWhile((e) => e < 9);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('takeWhile(e < 9, [1,2,3]) == []', async () => {
const a = iterator([1, 2, 3]);
const actual: number[] = [];
const expected: number[] = [];
const it = a.takeWhile((e) => e < 0);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/enumerate.ts
|
<filename>deno/methods/enumerate.ts
import { Pair, pair } from "../types/mod.ts";
import { next_async } from "../lib/iterable/mod.ts";
import { scan } from "./scan.ts";
async function* _enumerate_impl_fn<T>(
iter: AsyncIterable<T>,
): AsyncIterable<Pair<number, T>> {
const { done, value } = await next_async(iter);
if (done) {
return;
}
yield* scan(
([current], elem) => pair(current + 1, elem),
pair(0, value),
iter,
);
}
export function enumerate<T>(
iter: AsyncIterable<T>,
): AsyncIterable<Pair<number, T>> {
return _enumerate_impl_fn(iter);
}
|
syrflover/iterator-helper
|
src/types/mod.ts
|
<reponame>syrflover/iterator-helper
export type { Flatten } from './flatten.ts';
export type { Nullable } from './nullable.ts';
export type { Pair } from './pair.ts';
export type { ExtractPromise, EP } from './promise.ts';
export { Ord } from './ordering.ts';
export { pair } from './pair.ts';
|
syrflover/iterator-helper
|
src/methods/findMap_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('findMap() parseInt Succeeded', async () => {
const a = iterator(['a', 'b', '1', 'c', '2', '3']);
const actual = await a.findMap((e) => parseInt(e, 10));
const expected = 1;
assertEquals(actual, expected);
});
Deno.test('findMap() parseInt Failed', async () => {
const a = iterator(['a', 'b', 'c', 'd', 'e']);
const actual = await a.findMap((e) => parseInt(e, 10));
const expected = undefined;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/minBy.ts
|
<reponame>syrflover/iterator-helper<filename>deno/methods/minBy.ts<gh_stars>1-10
import type { CompareFn } from "../types/functions/mod.ts";
import { _curry, id } from "../lib/utils/mod.ts";
import { minByKey } from "./minByKey.ts";
export interface MinBy {
<T>(fn: CompareFn<T>, iter: AsyncIterable<T>): Promise<T | undefined>;
<T>(fn: CompareFn<T>): (iter: AsyncIterable<T>) => Promise<T | undefined>;
}
export const minBy: MinBy = _curry(
<T>(fn: CompareFn<T>, iter: AsyncIterable<T>) => {
return minByKey(id, fn, iter);
},
);
|
syrflover/iterator-helper
|
deno/methods/last.ts
|
<gh_stars>1-10
import { fold } from "./fold.ts";
// [a] -> Maybe a
export function last<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
return fold((_, e) => e, undefined as T | undefined, iter);
}
|
syrflover/iterator-helper
|
src/types/guards/isIterable.ts
|
<filename>src/types/guards/isIterable.ts
import { isFunction } from './isFunction.ts';
import { isNull } from './isNull.ts';
export function isIterable(a: any): a is Iterable<any> {
return isNull(a) ? false : isFunction(a[Symbol.iterator]);
}
|
syrflover/iterator-helper
|
src/methods/maxBy.ts
|
<filename>src/methods/maxBy.ts<gh_stars>1-10
import type { CompareFn } from '../types/functions/mod.ts';
import { getLogger } from '../logger.ts';
import { _curry, id } from '../lib/utils/mod.ts';
import { maxByKey } from './maxByKey.ts';
const logger = await getLogger('methods/maxBy');
export interface MaxBy {
<T>(fn: CompareFn<T>, iter: AsyncIterable<T>): Promise<T | undefined>;
<T>(fn: CompareFn<T>): (iter: AsyncIterable<T>) => Promise<T | undefined>;
}
export const maxBy: MaxBy = _curry(<T>(fn: CompareFn<T>, iter: AsyncIterable<T>) => {
logger.trace('maxBy()');
return maxByKey(id, fn, iter);
});
|
syrflover/iterator-helper
|
src/methods/skip.ts
|
import { getLogger } from '../logger.ts';
import { next_async } from '../lib/iterable/mod.ts';
import { _curry } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/skip');
async function* _skip_impl_fn<T>(count: number, iter: AsyncIterable<T>): AsyncIterable<T> {
logger.trace('skip()');
let current = 1;
while (true) {
const { done } = await next_async(iter);
logger.debug('done =', done);
logger.debug('count =', count);
logger.debug('current =', current);
if (done) {
return;
}
if (current >= count) {
yield* iter;
return;
}
current += 1;
}
}
export interface Skip {
<T>(count: number, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(count: number): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const skip: Skip = _curry(_skip_impl_fn);
|
syrflover/iterator-helper
|
src/lib/compare/minBy_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { id } from '../utils/mod.ts';
import { compare, minBy } from './mod.ts';
Deno.test('minBy(100, 1, compare) == 1', async () => {
const actual = await minBy(id, compare, 100, 1);
const expected = 1;
assertEquals(actual, expected);
});
Deno.test('minBy(1, 100, compare) == 1', async () => {
const actual = await minBy(id, compare, 100, 1);
const expected = 1;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/partition.ts
|
import type { PredicateFn } from "../types/functions/mod.ts";
import { Pair, pair } from "../types/mod.ts";
import { append, sequence } from "../lib/iterable/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
import { fold } from "./fold.ts";
async function _partition_impl_fn<T>(
fn: PredicateFn<T>,
iter: AsyncIterable<T>,
): Promise<Pair<AsyncIterable<T>, AsyncIterable<T>>> {
return fold(
async ([left, right], elem) => {
const condition = await fn(elem);
if (condition) {
return pair(append(elem, left), right);
}
return pair(left, append(elem, right));
},
pair(sequence<T>([]), sequence<T>([])),
iter,
);
}
export interface Partition {
<T>(
fn: PredicateFn<T>,
iter: AsyncIterable<T>,
): Promise<Pair<AsyncIterable<T>, AsyncIterable<T>>>;
<T>(
fn: PredicateFn<T>,
): (
iter: AsyncIterable<T>,
) => Promise<Pair<AsyncIterable<T>, AsyncIterable<T>>>;
}
export const partition: Partition = _curry(_partition_impl_fn);
|
syrflover/iterator-helper
|
src/methods/skipWhile.ts
|
<reponame>syrflover/iterator-helper
import type { PredicateFn } from '../types/functions/mod.ts';
import { getLogger } from '../logger.ts';
import { next_async, prepend } from '../lib/iterable/mod.ts';
import { _curry } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/dropWhile');
async function* _skip_while_impl_fn<T>(predicate: PredicateFn<T>, iter: AsyncIterable<T>): AsyncIterable<T> {
logger.trace('skipWhile()');
while (true) {
const { done, value } = await next_async(iter);
logger.debug('done =', done);
logger.debug('value =', value);
if (done) {
return;
}
const condition = await predicate(value);
logger.debug('condition =', condition);
if (!condition) {
yield* prepend(value, iter);
return;
}
}
}
export interface SkipWhile {
<T>(predicate: PredicateFn<T>, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(predicate: PredicateFn<T>): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const skipWhile: SkipWhile = _curry(_skip_while_impl_fn);
|
syrflover/iterator-helper
|
src/types/functions/map.ts
|
export type MapFn<T, R> = (elem: T) => R | Promise<R>;
|
syrflover/iterator-helper
|
src/types/guards/isPromise_test.ts
|
<reponame>syrflover/iterator-helper
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { isPromise } from './mod.ts';
Deno.test('isPromise() true', () => {
const actual = isPromise(Promise.resolve());
const expected = true;
assertEquals(actual, expected);
});
Deno.test('isPromise() undefined', () => {
const actual = isPromise(undefined);
const expected = false;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/iterator.ts
|
import type { ForEachFn, FoldFn, MapFn, PredicateFn, CompareFn, KeyFn, ScanFn, EqualFn } from './types/functions/mod.ts';
import { compare } from './lib/compare/mod.ts';
import { next_async, sequence } from './lib/iterable/mod.ts';
import { Flatten, Pair, pair, Nullable } from './types/mod.ts';
import {
all,
any,
average,
chain,
collect,
count,
cycle,
enumerate,
filter,
filterMap,
find,
findMap,
flatMap,
flatten,
fold,
fold1,
forEach,
head,
inspect,
last,
map,
max,
maxBy,
maxByKey,
min,
minBy,
minByKey,
nth,
nub,
nubBy,
partition,
position,
product,
reverse,
scan,
scan1,
skip,
skipWhile,
stepBy,
sum,
take,
takeWhile,
unzip,
zip,
} from './methods/mod.ts';
// prettier-ignore
export type ToAsyncIterator<T> =
T extends number ? IAsyncIterator_number :
T extends Pair<infer A, infer B> ? IAsyncIterator_zip<A, B> :
IAsyncIterator_<T>;
export interface IAsyncIterator_<T> extends AsyncIterableIterator<T> {
/**
* @see https://tc39.es/proposal-iterator-helpers/#sec-asynciteratorprototype-@@tostringtag
*/
[Symbol.toStringTag]: string;
/**
* similar Array.prototype.every
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.all
*/
all(fn: PredicateFn<T>): Promise<boolean>;
/**
* similar Array.prototype.some
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.any
*/
any(fn: PredicateFn<T>): Promise<boolean>;
/**
* similar concat
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.chain
*/
chain(other: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>): ToAsyncIterator<T>;
/**
* @description
* Convert AsyncIterator_ to Array
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect
*/
collect(): Promise<T[]>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.count
*/
count(): Promise<number>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.cycle
*/
cycle(): ToAsyncIterator<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.enumerate
*/
enumerate(): ToAsyncIterator<Pair<number, T>>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.filter
*/
filter(predicate: PredicateFn<T>): ToAsyncIterator<T>;
/**
* @description
* do not catch error
*
* filter only `null | undefined | NaN`
*
* @example
* ['a', 'b', '1', 'c', '2', '3']
* .iter()
* .filterMap(e => parseInt(e, 10))
* .collect(); // [1, 2, 3]
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.filter_map
*/
filterMap<R>(fn: MapFn<T, Nullable<R>>): ToAsyncIterator<R>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.find
*/
find(predicate: PredicateFn<T>): Promise<T | undefined>;
/**
* @description
* do not catch error
*
* filter only `null | undefined | NaN`
*
* @example
* ['a', 'b', '1', 'c', '2']
* .iter()
* .findMap(e => parseInt(e, 10)); // 1
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.find_map
*/
findMap<R>(fn: MapFn<T, Nullable<R>>): Promise<R | undefined>;
/**
* @example
* [`it's Sunny in`, '', 'California']
* .iter()
* .flatMap(e => e.split(' '))
* .collect(); // [`it's`, 'Sunny', 'in', '', 'California']
*
* @see https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.flat_map
*/
flatMap<R extends Iterable<any> | AsyncIterable<any>>(fn: MapFn<T, R>): ToAsyncIterator<Flatten<R>>;
/**
* @example
* [[1], [Promise.resolve(2), 3], 4, 5]
* .iter()
* .flatten()
* .collect(); // [1, 2, 3, 4, 5]
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.flatten
*/
flatten(): ToAsyncIterator<Flatten<T>>;
/**
* @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:foldl
*/
fold<U>(init: U | Promise<U>, fn: FoldFn<T, U>): Promise<U>;
/**
* @throws empty iterator
*
* @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:foldl1
*/
fold1(fn: FoldFn<T, T>): Promise<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.for_each
*/
forEach(fn: ForEachFn<T>): Promise<void>;
/**
* @description
* if empty iterator, return undefined
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#tymethod.next
*/
head(): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.inspect
*/
inspect(fn: ForEachFn<T>): ToAsyncIterator<T>;
/**
* @description
* if empty iterator, return undefined
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.last
*/
last(): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.map
*/
map<R>(fn: MapFn<T, R>): ToAsyncIterator<R>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.max
*/
max(): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.max_by
*/
maxBy(fn: CompareFn<T>): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.max_by_key
*/
maxByKey<K>(keyFn: KeyFn<T, K>, cmpFn?: CompareFn<K>): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.min
*/
min(): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.min_by
*/
minBy(fn: CompareFn<T>): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.min_by_key
*/
minByKey<K>(keyFn: KeyFn<T, K>, cmpFn?: CompareFn<K>): Promise<T | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.nth
*/
nth(n: number): Promise<T | undefined>;
/**
* @see https://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:nub
*/
nub(): ToAsyncIterator<T>;
/**
* @see https://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:nubBy
*/
nubBy(fn: EqualFn<T>): ToAsyncIterator<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.partition
*/
partition(fn: PredicateFn<T>): Promise<Pair<ToAsyncIterator<T>, ToAsyncIterator<T>>>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.position
*/
position(fn: PredicateFn<T>): Promise<number | undefined>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.rev
*/
reverse(): ToAsyncIterator<T>;
/**
* @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:scanl
*/
scan<U>(init: U | Promise<U>, fn: ScanFn<T, U>): ToAsyncIterator<U>;
/**
* @see http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#v:scanl1
*/
scan1(fn: ScanFn<T, T>): ToAsyncIterator<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.skip
*/
skip(count_: number): ToAsyncIterator<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.skip_while
*/
skipWhile(predicate: PredicateFn<T>): ToAsyncIterator<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.step_by
*/
stepBy(step: number): ToAsyncIterator<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.take
*/
take(count_: number): ToAsyncIterator<T>;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.take_while
*/
takeWhile(predicate: PredicateFn<T>): ToAsyncIterator<T>;
toString(): string;
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.zip
*/
zip<U>(other: Iterable<U | Promise<U>> | AsyncIterable<U | Promise<U>>): ToAsyncIterator<Pair<T, U>>;
}
export interface IAsyncIterator_number extends IAsyncIterator_<number> {
/**
* @example
* [1, 2, 3, 4, 5]
* .iter()
* .average(); // 3
*
* ([] as number[])
* .iter()
* .average(); // 0
*/
average(): Promise<number>;
/**
* @example
* [1, 2, 3, 4, 5]
* .iter()
* .product(); // 120
*
* ([] as number[])
* .iter()
* .product(); // 1
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.product
*/
product(): Promise<number>;
/**
* @example
* [1, 2, 3, 4, 5]
* .iter()
* .sum(); // 15
*
* ([] as number[])
* .iter()
* .sum(); // 0
*
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.sum
*/
sum(): Promise<number>;
}
export interface IAsyncIterator_zip<T, U> extends IAsyncIterator_<Pair<T, U>> {
/**
* @see https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.unzip
*/
unzip(): Promise<Pair<ToAsyncIterator<T>, ToAsyncIterator<U>>>;
}
export class AsyncIterator_<T> implements IAsyncIterator_<T> {
constructor(iter: AsyncIterable<T | Promise<T>>) {
this._iter = {
async *[Symbol.asyncIterator]() {
yield* iter;
},
};
Object.defineProperty(this, '_iter', {
configurable: false,
enumerable: false,
writable: false,
});
Object.defineProperty(this, Symbol.toStringTag, {
configurable: true,
enumerable: false,
writable: false,
});
}
private readonly _iter: AsyncIterable<T>;
public readonly [Symbol.toStringTag] = 'Async Iterator' as const;
public [Symbol.asyncIterator]() {
return this;
}
public async next() {
const { done, value } = await next_async(this._iter);
return {
done,
value,
};
}
public all(fn: PredicateFn<T>) {
return all<T>(fn, this);
}
public any(fn: PredicateFn<T>) {
return any<T>(fn, this);
}
public average() {
return average(this as any);
}
public chain(other: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>) {
return (new AsyncIterator_<T>(chain<T>(other, this)) as unknown) as ToAsyncIterator<T>;
}
public collect() {
return collect<T>(this);
}
public count() {
return count<T>(this);
}
public cycle() {
return (new AsyncIterator_<T>(cycle<T>(this)) as unknown) as ToAsyncIterator<T>;
}
public enumerate() {
return (new AsyncIterator_<Pair<number, T>>(enumerate<T>(this)) as unknown) as ToAsyncIterator<Pair<number, T>>;
}
public filter(predicate: PredicateFn<T>) {
return (new AsyncIterator_<T>(filter<T>(predicate, this)) as unknown) as ToAsyncIterator<T>;
}
public filterMap<R>(fn: MapFn<T, Nullable<R>>) {
return (new AsyncIterator_<R>(filterMap<T, R>(fn, this)) as unknown) as ToAsyncIterator<R>;
}
public find(predicate: PredicateFn<T>) {
return find<T>(predicate, this);
}
public findMap<R>(fn: MapFn<T, Nullable<R>>) {
return findMap<T, R>(fn, this);
}
public flatMap<R extends Iterable<any> | AsyncIterable<any>>(fn: MapFn<T, R>) {
return (new AsyncIterator_<Flatten<R>>(flatMap<T, R>(fn, this)) as unknown) as ToAsyncIterator<Flatten<R>>;
}
public flatten() {
return (new AsyncIterator_<Flatten<T>>(flatten<T>(this)) as unknown) as ToAsyncIterator<Flatten<T>>;
}
public fold<U>(init: U | Promise<U>, fn: FoldFn<T, U>) {
return fold<T, U>(fn, init, this);
}
public fold1(fn: FoldFn<T, T>) {
return fold1<T>(fn, this);
}
public forEach(fn: ForEachFn<T>) {
return forEach<T>(fn, this);
}
public head() {
return head<T>(this);
}
public inspect(fn: ForEachFn<T>) {
return (new AsyncIterator_<T>(inspect<T>(fn, this)) as unknown) as ToAsyncIterator<T>;
}
public last() {
return last<T>(this);
}
public map<R>(fn: MapFn<T, R>) {
return (new AsyncIterator_<R>(map<T, R>(fn, this)) as unknown) as ToAsyncIterator<R>;
}
public max() {
return max<T>(this);
}
public maxBy(fn: CompareFn<T>) {
return maxBy<T>(fn, this);
}
public maxByKey<K>(keyFn: KeyFn<T, K>, cmpFn: CompareFn<K> = compare) {
return maxByKey<T, K>(keyFn, cmpFn, this);
}
public min() {
return min<T>(this);
}
public minBy(fn: CompareFn<T>) {
return minBy<T>(fn, this);
}
public minByKey<K>(keyFn: KeyFn<T, K>, cmpFn: CompareFn<K> = compare) {
return minByKey<T, K>(keyFn, cmpFn, this);
}
public nth(n: number) {
return nth<T>(n, this);
}
public nub() {
return (new AsyncIterator_<T>(nub<T>(this)) as unknown) as ToAsyncIterator<T>;
}
public nubBy(fn: EqualFn<T>) {
return (new AsyncIterator_<T>(nubBy<T>(fn, this)) as unknown) as ToAsyncIterator<T>;
}
public async partition(fn: PredicateFn<T>) {
const [left, right] = await partition(fn, this);
return (pair(new AsyncIterator_<T>(left), new AsyncIterator_<T>(right)) as unknown) as Pair<ToAsyncIterator<T>, ToAsyncIterator<T>>;
}
public position(fn: PredicateFn<T>) {
return position<T>(fn, this);
}
public product() {
return product(this as any);
}
public reverse() {
return (new AsyncIterator_<T>(reverse<T>(this)) as unknown) as ToAsyncIterator<T>;
}
public scan<U>(init: U | Promise<U>, fn: ScanFn<T, U>) {
return (new AsyncIterator_<U>(scan<T, U>(fn, init, this)) as unknown) as ToAsyncIterator<U>;
}
public scan1(fn: ScanFn<T, T>) {
return (new AsyncIterator_<T>(scan1<T>(fn, this)) as unknown) as ToAsyncIterator<T>;
}
public skip(count_: number) {
return (new AsyncIterator_<T>(skip<T>(count_, this)) as unknown) as ToAsyncIterator<T>;
}
public skipWhile(predicate: PredicateFn<T>) {
return (new AsyncIterator_<T>(skipWhile<T>(predicate, this)) as unknown) as ToAsyncIterator<T>;
}
public stepBy(step: number) {
return (new AsyncIterator_<T>(stepBy<T>(step, this)) as unknown) as ToAsyncIterator<T>;
}
public sum() {
return sum(this as any);
}
public take(count_: number) {
return (new AsyncIterator_<T>(take<T>(count_, this)) as unknown) as ToAsyncIterator<T>;
}
public takeWhile(predicate: PredicateFn<T>) {
return (new AsyncIterator_<T>(takeWhile<T>(predicate, this)) as unknown) as ToAsyncIterator<T>;
}
public async unzip() {
const [left, right] = await unzip<any, any>(this as any);
return (pair(new AsyncIterator_<any>(left), new AsyncIterator_<any>(right)) as unknown) as Pair<ToAsyncIterator<any>, ToAsyncIterator<any>>;
}
public zip<U>(other: Iterable<U | Promise<U>> | AsyncIterable<U | Promise<U>>) {
return (new AsyncIterator_<Pair<T, U>>(zip<T, U>(other, this)) as unknown) as ToAsyncIterator<Pair<T, U>>;
}
}
export function iterator<T>(iter: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>) {
const it = sequence(iter);
return (new AsyncIterator_<T>(it) as unknown) as ToAsyncIterator<T>;
}
|
syrflover/iterator-helper
|
src/types/guards/isNull.ts
|
/**
* a is null | undefined | NaN
*/
export function isNull(a: any): a is null | undefined {
return a === null || a === undefined || Number.isNaN(a);
}
|
syrflover/iterator-helper
|
src/methods/scan1_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('scan1() state + elem', async () => {
const a = iterator([1, 2, 3, Promise.resolve(4), 5]);
const actual_elements: number[] = [];
const expected_elements = [2, 3, 4, 5];
const actual_result: number[] = [];
const expected_result = [1, 3, 6, 10, 15];
for await (const _ of a.scan1((st, e) => {
actual_elements.push(e);
return st + e;
})) {
actual_result.push(_);
}
assertEquals(actual_elements, expected_elements);
assertEquals(actual_result, expected_result);
});
|
syrflover/iterator-helper
|
src/types/ordering.ts
|
/* eslint-disable no-shadow */
export enum Ord {
Less = -1,
Equal = 0,
Greater = 1,
}
|
syrflover/iterator-helper
|
src/methods/zip_test.ts
|
<reponame>syrflover/iterator-helper<filename>src/methods/zip_test.ts
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import type { Pair } from '../types/mod.ts';
import { iterator } from '../mod.ts';
Deno.test('zip() [1,2,3,4].zip([5,6,7,8])', async () => {
const a = iterator([1, 2, 3, 4]);
const actual: Pair<number, number>[] = [];
const expected: Pair<number, number>[] = [
[1, 5],
[2, 6],
[3, 7],
[4, 8],
];
const it = a.zip([5, 6, 7, 8]);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test(`zip() [1,2,3,4].zip(['a','b','c','d','e'])`, async () => {
const a = iterator([1, 2, 3, 4]);
const actual: Pair<number, string>[] = [];
const expected: Pair<number, string>[] = [
[1, 'a'],
[2, 'b'],
[3, 'c'],
[4, 'd'],
];
const it = a.zip(['a', 'b', 'c', 'd', 'e']);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('zip() string', async () => {
const a = iterator([1, 2, 3, 4]);
const actual: Pair<number, string>[] = [];
const expected: Pair<number, string>[] = [
[1, 'h'],
[2, 'e'],
[3, 'l'],
[4, 'l'],
];
const it = a.zip('hello world');
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('zip() [1,2,3,4].zip([5,Promise(6),7,8])', async () => {
const a = iterator([1, 2, 3, 4]);
const actual: Pair<number, number>[] = [];
const expected: Pair<number, number>[] = [
[1, 5],
[2, 6],
[3, 7],
[4, 8],
];
const it = a.zip([5, Promise.resolve(6), 7, 8]);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('zip() empty iter', async () => {
const a = iterator<number>([]);
const actual: Pair<number, number>[] = [];
const expected: Pair<number, number>[] = [];
const it = a.zip([5, 6, 7, 8, 9]);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/methods/count_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('count() [1,2,3,4,5].length === count()', async () => {
const a = [1, 2, 3, 4, 5];
const actual = await iterator([1, 2, 3, 4, 5]).count();
const expected = a.length;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/head.ts
|
<reponame>syrflover/iterator-helper
import { next_async } from "../lib/iterable/mod.ts";
async function _head_impl_fn<T>(
iter: AsyncIterable<T>,
): Promise<T | undefined> {
const { done, value } = await next_async(iter);
if (done) {
return;
}
return value;
}
export function head<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
return _head_impl_fn(iter);
}
|
syrflover/iterator-helper
|
src/methods/average.ts
|
<filename>src/methods/average.ts
import { getLogger } from '../logger.ts';
import { pair, Pair } from '../types/mod.ts';
import { fold } from './fold.ts';
export const logger = await getLogger('methods/average');
async function _average_impl_fn(iter: AsyncIterable<number>) {
logger.trace('average()');
const [count, summed] = await fold(([current, value]: Pair<number, number>, e: number) => pair(current + 1, value + e), pair(0, 0), iter);
return count === 0 ? 0 : summed / count;
}
export function average(iter: AsyncIterable<number>) {
return _average_impl_fn(iter);
}
|
syrflover/iterator-helper
|
src/methods/take.ts
|
import { getLogger } from '../logger.ts';
import { _curry } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/take');
async function* _take_impl_fn<T>(limit: number, iter: AsyncIterable<T>): AsyncIterable<T> {
logger.trace('take()');
let current = 1;
for await (const elem of iter) {
if (current > limit) {
return;
}
logger.debug('element =', elem);
yield elem;
current += 1;
}
}
export interface Take {
<T>(limit: number, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(limit: number): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const take: Take = _curry(_take_impl_fn);
|
syrflover/iterator-helper
|
deno/methods/flatten.ts
|
import type { Flatten } from "../types/mod.ts";
import { isAsyncIterable, isIterable } from "../types/guards/mod.ts";
async function* _flatten_impl_fn<T>(
iter: AsyncIterable<T>,
): AsyncIterable<Flatten<T>> {
for await (const elem of iter) {
if (isIterable(elem) || isAsyncIterable(elem)) {
yield* elem;
} else {
yield elem as Flatten<T>;
}
}
}
export function flatten<T>(iter: AsyncIterable<T>): AsyncIterable<Flatten<T>> {
return _flatten_impl_fn(iter);
}
|
syrflover/iterator-helper
|
deno/methods/scan1.ts
|
import type { ScanFn } from "../types/functions/mod.ts";
import { next_async } from "../lib/iterable/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
import { scan } from "./scan.ts";
async function* _scan1_impl_fn<T>(
fn: ScanFn<T, T>,
iter: AsyncIterable<T>,
): AsyncIterable<T> {
const { done, value: head } = await next_async(iter);
if (done) {
return;
}
yield* scan(fn, head, iter);
}
export interface Scan1 {
<T>(fn: ScanFn<T, T>, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(fn: ScanFn<T, T>): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const scan1: Scan1 = _curry(_scan1_impl_fn);
|
syrflover/iterator-helper
|
src/methods/nubBy.ts
|
import type { EqualFn } from '../types/functions/mod.ts';
import { getLogger } from '../logger.ts';
import { sequence } from '../lib/iterable/mod.ts';
import { _curry } from '../lib/utils/mod.ts';
import { any } from './any.ts';
const logger = await getLogger('methods/nubBy');
async function* _nub_by_impl_fn<T>(fn: EqualFn<T>, iter: AsyncIterable<T>): AsyncIterable<T> {
logger.trace('nubBy()');
const prev: T[] = [];
for await (const elem of iter) {
if (!(await any((prev_elem) => fn(prev_elem, elem), sequence(prev)))) {
yield elem;
prev.push(elem);
}
}
}
export interface NubBy {
<T>(fn: EqualFn<T>, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(fn: EqualFn<T>): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const nubBy: NubBy = _curry(_nub_by_impl_fn);
|
syrflover/iterator-helper
|
deno/methods/nub.ts
|
<reponame>syrflover/iterator-helper
import { nubBy } from "./nubBy.ts";
export function nub<T>(iter: AsyncIterable<T>): AsyncIterable<T> {
return nubBy<T>((a, b) => a === b, iter);
}
|
syrflover/iterator-helper
|
deno/methods/filterMap.ts
|
import type { Nullable } from "../types/mod.ts";
import type { MapFn } from "../types/functions/mod.ts";
import { isNull } from "../types/guards/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
async function* _filter_map_impl_fn<T, R>(
fn: MapFn<T, Nullable<R>>,
iter: AsyncIterable<T>,
): AsyncIterable<R> {
for await (const elem of iter) {
const mapped = await fn(elem);
if (!isNull(mapped)) {
yield mapped;
}
}
}
export interface FilterMap {
<T, R>(fn: MapFn<T, Nullable<R>>, iter: AsyncIterable<T>): AsyncIterable<R>;
<T, R>(
fn: MapFn<T, Nullable<R>>,
): (iter: AsyncIterable<T>) => AsyncIterable<R>;
}
export const filterMap: FilterMap = _curry(_filter_map_impl_fn);
|
syrflover/iterator-helper
|
src/types/guards/isString.ts
|
import { isNull } from './isNull.ts';
export function isString(a: any): a is string {
return isNull(a) ? false : a.constructor === String;
}
|
syrflover/iterator-helper
|
src/lib/iterable/prepend_test.ts
|
<reponame>syrflover/iterator-helper
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { prepend } from './mod.ts';
Deno.test('prepend(0, [1])', async () => {
const actual: number[] = [];
const expected = [0, 1];
for await (const _ of prepend(0, [1])) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/lib/utils/mod.ts
|
export * from './$.ts';
export * from './curry.ts';
export * from './flip.ts';
export * from './id.ts';
export * from './pipe.ts';
|
syrflover/iterator-helper
|
src/types/functions/equal.ts
|
<gh_stars>1-10
export type EqualFn<T> = (a: T, b: T) => boolean | Promise<boolean>;
|
syrflover/iterator-helper
|
src/methods/forEach_test.ts
|
<reponame>syrflover/iterator-helper<gh_stars>1-10
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('forEach() [1,2,3,4,5,6]', async () => {
const a = [1, 2, 3, 4, 5, 6];
let actual = 0;
const expected = a.length;
const r = await iterator(a).forEach((_) => {
actual += 1;
});
assertEquals(actual, expected);
assertEquals(r, undefined);
});
|
syrflover/iterator-helper
|
src/methods/enumerate.ts
|
import { getLogger } from '../logger.ts';
import { pair, Pair } from '../types/mod.ts';
import { next_async } from '../lib/iterable/mod.ts';
import { scan } from './scan.ts';
const logger = await getLogger('methods/enumerate');
async function* _enumerate_impl_fn<T>(iter: AsyncIterable<T>): AsyncIterable<Pair<number, T>> {
logger.trace('enumerate()');
const { done, value } = await next_async(iter);
if (done) {
return;
}
yield* scan(([current], elem) => pair(current + 1, elem), pair(0, value), iter);
}
export function enumerate<T>(iter: AsyncIterable<T>): AsyncIterable<Pair<number, T>> {
return _enumerate_impl_fn(iter);
}
|
syrflover/iterator-helper
|
src/methods/stepBy.ts
|
<filename>src/methods/stepBy.ts
import { getLogger } from '../logger.ts';
import { _curry } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/stepBy');
async function* _step_by_impl_fn<T>(step: number, iter: AsyncIterable<T>): AsyncIterable<T> {
logger.trace('stepBy()');
let current_step = 0;
for await (const elem of iter) {
if (current_step % step === 0 || current_step === 0) {
yield elem;
}
current_step += 1;
}
}
export interface StepBy {
<T>(step: number, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(step: number): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const stepBy: StepBy = _curry(_step_by_impl_fn);
|
syrflover/iterator-helper
|
src/types/functions/fold.ts
|
<reponame>syrflover/iterator-helper
export type FoldFn<A, B> = (accumulator: B, elem: A) => B | Promise<B>;
// export type FoldrFn<A, B> = (elem: A, accumulator: B) => B | Promise<B>;
|
syrflover/iterator-helper
|
src/methods/unzip.ts
|
import { getLogger } from '../logger.ts';
import { Pair, pair } from '../types/mod.ts';
import { append, sequence } from '../lib/iterable/mod.ts';
import { fold } from './fold.ts';
const logger = await getLogger('methods/unzip');
async function _unzip_impl_fn<T, U>(iter: AsyncIterable<Pair<T, U>>): Promise<Pair<AsyncIterable<T>, AsyncIterable<U>>> {
logger.trace('unzip()');
return fold(
(acc, elem) => {
const [left_iter, right_iter] = acc;
const [left_value, right_value] = elem;
return pair(append(left_value, left_iter), append(right_value, right_iter));
},
pair(sequence<T>([]), sequence<U>([])),
iter,
);
}
export function unzip<T, U>(iter: AsyncIterable<Pair<T, U>>): Promise<Pair<AsyncIterable<T>, AsyncIterable<U>>> {
return _unzip_impl_fn(iter);
}
|
syrflover/iterator-helper
|
deno/lib/utils/id.ts
|
export const id = <T>(e: T): T => e;
|
syrflover/iterator-helper
|
src/types/functions/key.ts
|
export type KeyFn<T, K> = (elem: T) => K | Promise<K>;
|
syrflover/iterator-helper
|
src/methods/fold1_test.ts
|
<reponame>syrflover/iterator-helper
import { assert, assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('fold1() sum', async () => {
const a = iterator([1, 2, 3, Promise.resolve(4), 5]);
const actual = await a.fold1((acc, e) => acc + e);
const expected = 15;
assertEquals(actual, expected);
});
Deno.test(`fold1() empty iter')`, async () => {
const a = iterator<number>([]);
try {
await a.fold1((acc, e) => acc + e);
} catch (error) {
assert(/least one element is required in iterator/i.test(error.message));
}
});
|
syrflover/iterator-helper
|
deno/methods/max.ts
|
import { compare } from "../lib/compare/mod.ts";
import { maxBy } from "./maxBy.ts";
export function max<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
return maxBy(compare, iter);
}
|
syrflover/iterator-helper
|
src/methods/map_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('map() [1,2,3,4,5] -> [2,3,4,5,6]', async () => {
const a = iterator([1, 2, 3, 4, 5]);
const actual: number[] = [];
const expected = [2, 3, 4, 5, 6];
for await (const _ of a.map((e) => e + 1)) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test(`map() [1,2,3,4,5] -> ['1','2','3','4','5']`, async () => {
const a = iterator([1, 2, 3, 4, 5]);
const actual: string[] = [];
const expected = ['1', '2', '3', '4', '5'];
for await (const _ of a.map((e) => `${e}`)) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/product.ts
|
<reponame>syrflover/iterator-helper<filename>deno/methods/product.ts
import { fold } from "./fold.ts";
export function product(iter: AsyncIterable<number>): Promise<number> {
return fold((acc, e) => acc * e, 1, iter);
}
|
syrflover/iterator-helper
|
src/methods/collect.ts
|
<reponame>syrflover/iterator-helper
import { getLogger } from '../logger.ts';
import { fold } from './fold.ts';
const logger = await getLogger('methods/collect');
export function collect<T>(iter: AsyncIterable<T>): Promise<T[]> {
logger.trace('collect()');
return fold((acc: T[], e: T) => [...acc, e], [] as T[], iter);
}
|
syrflover/iterator-helper
|
deno/methods/find.ts
|
<filename>deno/methods/find.ts
import type { PredicateFn } from "../types/functions/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
async function _find_impl_fn<T>(
predicate: PredicateFn<T>,
iter: AsyncIterable<T>,
): Promise<T | undefined> {
for await (const elem of iter) {
const condition = await predicate(elem);
if (condition) {
return elem;
}
}
}
export interface Find {
<T>(
predicate: PredicateFn<T>,
iter: AsyncIterable<T>,
): Promise<T | undefined>;
<T>(
predicate: PredicateFn<T>,
): (iter: AsyncIterable<T>) => Promise<T | undefined>;
}
export const find: Find = _curry(_find_impl_fn);
|
syrflover/iterator-helper
|
deno/lib/iterable/append.ts
|
export async function* append<T>(x: T, xs: Iterable<T> | AsyncIterable<T>): AsyncIterable<T> {
yield* xs;
yield x;
}
|
syrflover/iterator-helper
|
deno/methods/skipWhile.ts
|
import type { PredicateFn } from "../types/functions/mod.ts";
import { next_async, prepend } from "../lib/iterable/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
async function* _skip_while_impl_fn<T>(
predicate: PredicateFn<T>,
iter: AsyncIterable<T>,
): AsyncIterable<T> {
while (true) {
const { done, value } = await next_async(iter);
if (done) {
return;
}
const condition = await predicate(value);
if (!condition) {
yield* prepend(value, iter);
return;
}
}
}
export interface SkipWhile {
<T>(predicate: PredicateFn<T>, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(predicate: PredicateFn<T>): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const skipWhile: SkipWhile = _curry(_skip_while_impl_fn);
|
syrflover/iterator-helper
|
src/lib/utils/pipe_test.ts
|
<filename>src/lib/utils/pipe_test.ts
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { pipe } from './mod.ts';
Deno.test('pipe()', async () => {
const fn = pipe(
(a: number) => a + 1,
async (a) => a * 3,
(a) => a / 2,
);
const actual = await fn(1);
const expected = 3;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/methods/flatten.ts
|
<gh_stars>1-10
import type { Flatten } from '../types/mod.ts';
import { getLogger } from '../logger.ts';
import { isIterable, isAsyncIterable } from '../types/guards/mod.ts';
const logger = await getLogger('methods/flatten');
async function* _flatten_impl_fn<T>(iter: AsyncIterable<T>): AsyncIterable<Flatten<T>> {
logger.trace('flatten()');
for await (const elem of iter) {
logger.debug('element =', elem);
if (isIterable(elem) || isAsyncIterable(elem)) {
yield* elem;
} else {
yield elem as Flatten<T>;
}
}
}
export function flatten<T>(iter: AsyncIterable<T>): AsyncIterable<Flatten<T>> {
return _flatten_impl_fn(iter);
}
|
syrflover/iterator-helper
|
src/lib/compare/min_test.ts
|
<gh_stars>1-10
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { min } from './mod.ts';
Deno.test('min(100, 1, compare) == 1', async () => {
const actual = await min(100, 1);
const expected = 1;
assertEquals(actual, expected);
});
Deno.test('min(1, 100, compare) == 1', async () => {
const actual = await min(100, 1);
const expected = 1;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/chain.ts
|
import { _curry } from "../lib/utils/mod.ts";
async function* _chain_impl_fn<T>(
other: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>,
iter: AsyncIterable<T>,
): AsyncIterable<T> {
yield* iter;
yield* other;
}
export interface Chain {
<T>(
other: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>,
iter: AsyncIterable<T>,
): AsyncIterable<T>;
<T>(
other: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>,
): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const chain: Chain = _curry(_chain_impl_fn);
|
syrflover/iterator-helper
|
src/methods/minBy_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { Ord } from '../types/mod.ts';
import { compare } from '../lib/compare/mod.ts';
import { iterator } from '../mod.ts';
function _compare<T>(a: T, b: T): Ord {
if (a > b) {
return Ord.Less;
}
if (a < b) {
return Ord.Greater;
}
return Ord.Equal;
}
Deno.test('minBy() [1,2,3,4,5]', async () => {
const a = iterator([1, 2, 3, Promise.resolve(4), 5]);
const actual = await a.minBy(compare);
const expected = 1;
assertEquals(actual, expected);
});
Deno.test('minBy() custom compare', async () => {
const i = iterator([1, 2, 3, Promise.resolve(4), 5]);
const actual = await i.minBy(_compare);
const expected = 5;
assertEquals(actual, expected);
});
Deno.test('minBy() empty iter', async () => {
const a = iterator<number>([]);
const actual = await a.minBy(compare);
const expected = undefined;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/methods/take_test.ts
|
<gh_stars>1-10
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('take(4)', async () => {
const a = iterator([1, 2, 3, 4, 5, 6, 7, 8]);
const actual: number[] = [];
const expected = [1, 2, 3, 4];
const it = a.take(4);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('take(Infinity)', async () => {
const a = iterator([1, 2, 3, 4, 5, 6, 7, 8]);
const actual: number[] = [];
const expected = [1, 2, 3, 4, 5, 6, 7, 8];
const it = a.take(Infinity);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/takeWhile.ts
|
<gh_stars>1-10
import type { PredicateFn } from "../types/functions/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
async function* _take_while_impl_fn<T>(
predicate: PredicateFn<T>,
iter: AsyncIterable<T>,
): AsyncIterable<T> {
for await (const elem of iter) {
const condition = await predicate(elem);
if (!condition) {
return;
}
yield elem;
}
}
export interface TakeWhile {
<T>(predicate: PredicateFn<T>, iter: AsyncIterable<T>): AsyncIterable<T>;
<T>(predicate: PredicateFn<T>): (iter: AsyncIterable<T>) => AsyncIterable<T>;
}
export const takeWhile: TakeWhile = _curry(_take_while_impl_fn);
|
syrflover/iterator-helper
|
deno/lib/utils/$.ts
|
<filename>deno/lib/utils/$.ts<gh_stars>1-10
import { sequence } from '../iterable/mod.ts';
import { fold } from '../../methods/mod.ts';
export function $<P, R1>(p: P | Promise<P>, f0: (p: P) => R1 | Promise<R1>): Promise<R1>;
export function $<P, R1, R2>(p: P | Promise<P>, f0: (p: P) => R1 | Promise<R1>, f1: (r0: R1) => R2 | Promise<R2>): Promise<R2>;
export function $<P, R1, R2, R3>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
): Promise<R3>;
export function $<P, R1, R2, R3, R4>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
): Promise<R4>;
export function $<P, R1, R2, R3, R4, R5>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
): Promise<R5>;
export function $<P, R1, R2, R3, R4, R5, R6>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
): Promise<R6>;
export function $<P, R1, R2, R3, R4, R5, R6, R7>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
): Promise<R7>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
): Promise<R8>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
): Promise<R9>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
): Promise<R10>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
): Promise<R11>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
): Promise<R12>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
): Promise<R13>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
f13: (r12: R13) => R14 | Promise<R14>,
): Promise<R14>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
f13: (r12: R13) => R14 | Promise<R14>,
f14: (r13: R14) => R15 | Promise<R15>,
): Promise<R15>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
f13: (r12: R13) => R14 | Promise<R14>,
f14: (r13: R14) => R15 | Promise<R15>,
f15: (r14: R15) => R16 | Promise<R16>,
): Promise<R16>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
f13: (r12: R13) => R14 | Promise<R14>,
f14: (r13: R14) => R15 | Promise<R15>,
f15: (r14: R15) => R16 | Promise<R16>,
f16: (r15: R16) => R17 | Promise<R17>,
): Promise<R17>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
f13: (r12: R13) => R14 | Promise<R14>,
f14: (r13: R14) => R15 | Promise<R15>,
f15: (r14: R15) => R16 | Promise<R16>,
f16: (r15: R16) => R17 | Promise<R17>,
f17: (r16: R17) => R18 | Promise<R18>,
): Promise<R18>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
f13: (r12: R13) => R14 | Promise<R14>,
f14: (r13: R14) => R15 | Promise<R15>,
f15: (r14: R15) => R16 | Promise<R16>,
f16: (r15: R16) => R17 | Promise<R17>,
f17: (r16: R17) => R18 | Promise<R18>,
f18: (r17: R18) => R19 | Promise<R19>,
): Promise<R19>;
export function $<P, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20>(
p: P | Promise<P>,
f0: (p: P) => R1 | Promise<R1>,
f1: (r0: R1) => R2 | Promise<R2>,
f2: (r1: R2) => R3 | Promise<R3>,
f3: (r2: R3) => R4 | Promise<R4>,
f4: (r3: R4) => R5 | Promise<R5>,
f5: (r4: R5) => R6 | Promise<R6>,
f6: (r5: R6) => R7 | Promise<R7>,
f7: (r6: R7) => R8 | Promise<R8>,
f8: (r7: R8) => R9 | Promise<R9>,
f9: (r8: R9) => R10 | Promise<R10>,
f10: (r9: R10) => R11 | Promise<R11>,
f11: (r10: R11) => R12 | Promise<R12>,
f12: (r11: R12) => R13 | Promise<R13>,
f13: (r12: R13) => R14 | Promise<R14>,
f14: (r13: R14) => R15 | Promise<R15>,
f15: (r14: R15) => R16 | Promise<R16>,
f16: (r15: R16) => R17 | Promise<R17>,
f17: (r16: R17) => R18 | Promise<R18>,
f18: (r17: R18) => R19 | Promise<R19>,
f19: (r18: R19) => R20 | Promise<R20>,
): Promise<R20>;
export function $(p: any, ...fns: any[]) {
return fold((acc: any, fn: any) => fn(acc), p, sequence(fns));
}
|
syrflover/iterator-helper
|
deno/mod.ts
|
<gh_stars>1-10
export type { AsyncIterator_, ToAsyncIterator, IAsyncIterator_, IAsyncIterator_number, IAsyncIterator_zip } from './iterator.ts';
export { iterator } from './iterator.ts';
export * from './methods/mod.ts';
|
syrflover/iterator-helper
|
src/methods/partition.ts
|
<reponame>syrflover/iterator-helper<gh_stars>1-10
import type { PredicateFn } from '../types/functions/mod.ts';
import { getLogger } from '../logger.ts';
import { pair, Pair } from '../types/mod.ts';
import { append, sequence } from '../lib/iterable/mod.ts';
import { _curry } from '../lib/utils/mod.ts';
import { fold } from './fold.ts';
const logger = await getLogger('methods/partition');
async function _partition_impl_fn<T>(fn: PredicateFn<T>, iter: AsyncIterable<T>): Promise<Pair<AsyncIterable<T>, AsyncIterable<T>>> {
logger.trace('partition()');
return fold(
async ([left, right], elem) => {
const condition = await fn(elem);
if (condition) {
return pair(append(elem, left), right);
}
return pair(left, append(elem, right));
},
pair(sequence<T>([]), sequence<T>([])),
iter,
);
}
export interface Partition {
<T>(fn: PredicateFn<T>, iter: AsyncIterable<T>): Promise<Pair<AsyncIterable<T>, AsyncIterable<T>>>;
<T>(fn: PredicateFn<T>): (iter: AsyncIterable<T>) => Promise<Pair<AsyncIterable<T>, AsyncIterable<T>>>;
}
export const partition: Partition = _curry(_partition_impl_fn);
|
syrflover/iterator-helper
|
src/types/functions/compare.ts
|
import type { Ord } from '../mod.ts';
export type CompareFn<T> = (a: T, b: T) => Ord | Promise<Ord>;
|
syrflover/iterator-helper
|
deno/methods/count.ts
|
<gh_stars>1-10
import { fold } from "./fold.ts";
// [a] -> Int
export function count<T>(iter: AsyncIterable<T>): Promise<number> {
return fold((count_: number) => count_ + 1, 0, iter);
}
|
syrflover/iterator-helper
|
src/types/pair.ts
|
export type Pair<T, U> = [T, U];
export function pair<T, U>(first: T, second: U): Pair<T, U> {
return [first, second];
}
|
syrflover/iterator-helper
|
deno/methods/cycle.ts
|
async function* _cycle_impl_fn<T>(iter: AsyncIterable<T>): AsyncIterable<T> {
const r: T[] = [];
for await (const elem of iter) {
yield elem;
r.push(elem);
}
while (true) {
yield* r;
}
}
export function cycle<T>(iter: AsyncIterable<T>): AsyncIterable<T> {
return _cycle_impl_fn(iter);
}
|
syrflover/iterator-helper
|
src/types/guards/isAsyncIterable.ts
|
import { isFunction } from './isFunction.ts';
import { isNull } from './isNull.ts';
export function isAsyncIterable(a: any): a is AsyncIterable<any> {
return isNull(a) ? false : isFunction(a[Symbol.asyncIterator]);
}
|
syrflover/iterator-helper
|
src/methods/nth.ts
|
<filename>src/methods/nth.ts
import { getLogger } from '../logger.ts';
import { _curry } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/nth');
async function _nth_impl_fn<T>(n: number, iter: AsyncIterable<T>): Promise<T | undefined> {
logger.trace('nth()');
let current = 0;
for await (const elem of iter) {
if (n === current) {
return elem;
}
current += 1;
}
}
export interface Nth {
<T>(n: number, iter: AsyncIterable<T>): Promise<T | undefined>;
<T>(n: number): (iter: AsyncIterable<T>) => Promise<T | undefined>;
}
export const nth: Nth = _curry(_nth_impl_fn);
|
syrflover/iterator-helper
|
src/lib/compare/maxBy_test.ts
|
<reponame>syrflover/iterator-helper
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { id } from '../utils/mod.ts';
import { compare, maxBy } from './mod.ts';
Deno.test('maxBy(100, 1, compare) == 100', async () => {
const actual = await maxBy(id, compare, 100, 1);
const expected = 100;
assertEquals(actual, expected);
});
Deno.test('maxBy(1, 100, compare) == 100', async () => {
const actual = await maxBy(id, compare, 100, 1);
const expected = 100;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/types/functions/predicate.ts
|
<gh_stars>1-10
export type PredicateFn<T> = (elem: T) => boolean | Promise<boolean>;
|
syrflover/iterator-helper
|
src/methods/skip_test.ts
|
<filename>src/methods/skip_test.ts<gh_stars>1-10
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('skip(4)', async () => {
const a = iterator([1, 2, 3, 4, 5, 6, 7, 8]);
const actual: number[] = [];
const expected = [5, 6, 7, 8];
const it = a.skip(4);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
Deno.test('skip(Infinity)', async () => {
const a = iterator([1, 2, 3, 4, 5, 6, 7, 8]);
const actual: number[] = [];
const expected: number[] = [];
const it = a.skip(Infinity);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/lib/compare/compare_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { Ord } from '../../types/mod.ts';
import { compare } from './mod.ts';
Deno.test('compare(100, 1) == Greater', () => {
const actual = compare(100, 1);
const expected = Ord.Greater;
assertEquals(actual, expected);
});
Deno.test('compare(1, 1) == Equal', () => {
const actual = compare(1, 1);
const expected = Ord.Equal;
assertEquals(actual, expected);
});
Deno.test('compare(1, 100) == Less', () => {
const actual = compare(1, 100);
const expected = Ord.Less;
assertEquals(actual, expected);
});
Deno.test('compare() Array.sort(compare)', () => {
const a = [1, 4, 11, 5, 2, 3];
const actual = a.sort(compare);
const expected = [1, 2, 3, 4, 5, 11];
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/methods/min.ts
|
<gh_stars>1-10
import { getLogger } from '../logger.ts';
import { compare } from '../lib/compare/mod.ts';
import { minBy } from './minBy.ts';
const logger = await getLogger('methods/min');
export function min<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
logger.trace('min()');
return minBy(compare, iter);
}
|
syrflover/iterator-helper
|
src/types/guards/isFunction.ts
|
import { isNull } from './isNull.ts';
export function isFunction(a: any): a is Function {
return isNull(a) ? false : a.constructor === Function;
}
|
syrflover/iterator-helper
|
src/methods/reverse.ts
|
import { getLogger } from '../logger.ts';
import { fold } from './fold.ts';
import { prepend, sequence } from '../lib/iterable/mod.ts';
import { flip } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/reverse');
async function* _reverse_impl_fn<T>(iter: AsyncIterable<T>): AsyncIterable<T> {
logger.trace('reverse()');
const emptyIter = sequence<T>([]);
yield* await fold((acc, e) => flip(prepend, acc, e), emptyIter, iter);
}
export function reverse<T>(iter: AsyncIterable<T>): AsyncIterable<T> {
return _reverse_impl_fn(iter);
}
|
syrflover/iterator-helper
|
src/methods/maxByKey_test.ts
|
<reponame>syrflover/iterator-helper
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { Ord } from '../types/mod.ts';
import { iterator } from '../mod.ts';
function _cmp<T>(a: T, b: T): Ord {
if (a > b) {
return Ord.Less;
}
if (a < b) {
return Ord.Greater;
}
return Ord.Equal;
}
Deno.test('maxByKey() [1,2,-3,4,5,-10].maxByKey(Math.abs)', async () => {
const a = iterator([1, 2, -3, Promise.resolve(4), 5, -10]);
const actual = await a.maxByKey(Math.abs);
const expected = -10;
assertEquals(actual, expected);
});
Deno.test('maxByKey() object', async () => {
const a = [
{ a: 6, b: 11 },
{ a: 4, b: 7 },
{ a: 1, b: 5 },
{ a: 3, b: 2 },
{ a: 11, b: 1 },
{ a: 5, b: 4 },
{ a: 2, b: 3 },
{ a: 7, b: 6 },
];
const actual_a = await iterator(a).maxByKey((e) => e.a);
const expected_a = { a: 11, b: 1 };
const actual_b = await iterator(a).maxByKey((e) => e.b);
const expected_b = { a: 6, b: 11 };
assertEquals(actual_a, expected_a);
assertEquals(actual_b, expected_b);
});
Deno.test('maxByKey() custom cmp', async () => {
const a = iterator([1, 2, -3, Promise.resolve(4), 5, -10]);
const actual = await a.maxByKey(Math.abs, _cmp);
const expected = 1;
assertEquals(actual, expected);
});
Deno.test('maxByKey() empty iter', async () => {
const a = iterator<number>([]);
const actual = await a.maxByKey((e) => e);
const expected = undefined;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/methods/nubBy_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test(`nubBy() ['a', 'bb', 'ccc']`, async () => {
const a = iterator(['a', 'bb', 'b', 'ccc', 'aa', 'cc', 'aaa']);
const actual: string[] = [];
const expected = ['a', 'bb', 'ccc'];
const it = a.nubBy((e1, e2) => e1.length === e2.length);
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/lib/iterable/mod.ts
|
<gh_stars>1-10
export * from './append.ts';
export * from './init.ts';
export * from './initLast.ts';
export * from './prepend.ts';
// convert
export * from './toIterable.ts';
export * from './toAsyncIterable.ts';
// util
export * from './next.ts';
|
syrflover/iterator-helper
|
src/methods/find.ts
|
<gh_stars>1-10
import type { PredicateFn } from '../types/functions/mod.ts';
import { getLogger } from '../logger.ts';
import { _curry } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/find');
async function _find_impl_fn<T>(predicate: PredicateFn<T>, iter: AsyncIterable<T>): Promise<T | undefined> {
logger.trace('find()');
for await (const elem of iter) {
const condition = await predicate(elem);
logger.debug('element =', elem);
logger.debug('condition =', condition);
if (condition) {
return elem;
}
}
}
export interface Find {
<T>(predicate: PredicateFn<T>, iter: AsyncIterable<T>): Promise<T | undefined>;
<T>(predicate: PredicateFn<T>): (iter: AsyncIterable<T>) => Promise<T | undefined>;
}
export const find: Find = _curry(_find_impl_fn);
|
syrflover/iterator-helper
|
src/methods/all.ts
|
import type { PredicateFn } from '../types/functions/mod.ts';
import { getLogger } from '../logger.ts';
import { _curry } from '../lib/utils/mod.ts';
const logger = await getLogger('methods/all');
async function _all_impl_fn<T>(fn: PredicateFn<T>, iter: AsyncIterable<T>): Promise<boolean> {
logger.trace('all()');
for await (const elem of iter) {
const condition = await fn(elem);
logger.debug('element =', elem);
logger.debug('condition =', condition);
if (!condition) {
return false;
}
}
return true;
}
export interface All {
<T>(fn: PredicateFn<T>, iter: AsyncIterable<T>): Promise<boolean>;
<T>(fn: PredicateFn<T>): (iter: AsyncIterable<T>) => Promise<boolean>;
}
export const all: All = _curry(_all_impl_fn);
|
syrflover/iterator-helper
|
src/lib/compare/max_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { max } from './mod.ts';
Deno.test('max(100, 1, compare) == 100', async () => {
const actual = await max(100, 1);
const expected = 100;
assertEquals(actual, expected);
});
Deno.test('max(1, 100, compare) == 100', async () => {
const actual = await max(100, 1);
const expected = 100;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/lib/utils/$_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { $ } from './mod.ts';
Deno.test('$()', async () => {
const actual = await $(
1,
(a) => a + 1,
(a) => a * 3,
async (a) => a / 2,
);
const expected = 3;
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
src/lib/utils/curry_test.ts
|
<gh_stars>1-10
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { curry } from './mod.ts';
Deno.test('curry() add a b', () => {
const add = (a: number, b: number) => a + b;
const curried = curry(add);
const add_2 = curried(2);
assertEquals(add_2(5), 7);
});
Deno.test('curry() add a b c d', () => {
const add = (a: number, b: number, c: number, d: number) => a + b + c + d;
const curried = curry(add);
const add_2 = curried(2);
const add_2_3 = add_2(3);
assertEquals(add_2(3)(4)(5), 14);
assertEquals(add_2(3)(4, 5), 14);
assertEquals(add_2(3, 4)(5), 14);
assertEquals(add_2(3, 4, 5), 14);
assertEquals(add_2_3(4, 5), 14);
assertEquals(add_2_3(4)(5), 14);
});
|
syrflover/iterator-helper
|
src/methods/enumerate_test.ts
|
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { pair, Pair } from '../types/mod.ts';
import { iterator } from '../mod.ts';
Deno.test(`enumerate(['a', 'b', 'c', 'd', 'e'])`, async () => {
const a = iterator(['a', 'b', 'c', 'd', 'e']);
const actual: Pair<number, string>[] = [];
const expected = [pair(0, 'a'), pair(1, 'b'), pair(2, 'c'), pair(3, 'd'), pair(4, 'e')];
for await (const _ of a.enumerate()) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
syrflover/iterator-helper
|
deno/methods/flatMap.ts
|
<reponame>syrflover/iterator-helper
import type { Flatten } from "../types/mod.ts";
import type { MapFn } from "../types/functions/mod.ts";
import { _curry } from "../lib/utils/mod.ts";
async function* _flat_map_impl_fn<
T,
R extends Iterable<any> | AsyncIterable<any>,
>(
fn: MapFn<T, R>,
iter: AsyncIterable<T>,
): AsyncIterable<Flatten<R>> {
for await (const elem of iter) {
const mapped = await fn(elem);
yield* mapped as AsyncIterable<any>;
}
}
export interface FlatMap {
<T, R extends Iterable<any> | AsyncIterable<any>>(
fn: MapFn<T, R>,
iter: AsyncIterable<T>,
): AsyncIterable<Flatten<R>>;
<T, R extends Iterable<any> | AsyncIterable<any>>(
fn: MapFn<T, R>,
): (iter: AsyncIterable<T>) => AsyncIterable<Flatten<R>>;
}
export const flatMap: FlatMap = _curry(_flat_map_impl_fn);
|
syrflover/iterator-helper
|
src/methods/last.ts
|
import { getLogger } from '../logger.ts';
import { fold } from './fold.ts';
const logger = await getLogger('methods/last');
// [a] -> Maybe a
export function last<T>(iter: AsyncIterable<T>): Promise<T | undefined> {
logger.trace('last()');
return fold((_, e) => e, undefined as T | undefined, iter);
}
|
syrflover/iterator-helper
|
src/methods/nub_test.ts
|
<reponame>syrflover/iterator-helper
import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
import { iterator } from '../mod.ts';
Deno.test('nub() [1, 2, 3, 4, 5, 6]', async () => {
const a = iterator([1, 2, 1, 3, 2, 4, 3, 5, 4, 1, 5, 6]);
const actual: number[] = [];
const expected = [1, 2, 3, 4, 5, 6];
const it = a.nub();
for await (const _ of it) {
actual.push(_);
}
assertEquals(actual, expected);
});
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.