jajaperson / iterable-utilities Goto Github PK

I forgot to update version string from "3.2.1" to "3.2.2" when fixing broken NPM release.

How to reproduce

import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts"
import { chunkify } from "https://deno.land/x/[email protected]/mod.ts"

const numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
const expected = [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]

assertEquals([...chunkify(numbers, 2)], expected)

Result

Uncaught AssertionError: Values are not equal:


    [Diff] Actual / Expected


    [
      [
        0,
        1,
      ],
+     [
+       2,
+       3,
+     ],
+     [
+       4,
+       5,
+     ],
+     [
+       6,
+       7,
+     ],
+     [
+       8,
+       9,
+     ],
    ]

    at assertEquals (https://deno.land/[email protected]/testing/asserts.ts:214:9)
    at <anonymous>:38:1

Reason

the return statement is inside the for loop, only executing it once.

protecting main branch will make force pushes harder and commit history more secure.

reference: https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches#require-pull-request-reviews-before-merging

interface Array<T> {
    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise.
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined.
     * @param thisArg If provided, it will be used as the this value for each invocation of
     * predicate. If it is not provided, undefined is used instead.
     */
    find<S extends T>(predicate: (value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined
    find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined
}

(code from https://github.com/microsoft/TypeScript/blob/4d5ba0316a43ea31c41c50e4d62756659ddffbaa/src/lib/es2015.core.d.ts#L1-L12)

functions like find and filter should be able to utilize type predicates.

Todo

Overloads

• find
• filter
• every
• takeWhile
• dropWhile

handle curryIterFunction

related:

• https://stackoverflow.com/questions/48892283/typescript-overload-considers-only-one-of-the-overloaded-signatures
• https://stackoverflow.com/questions/39407311/typescript-class-overload-signature-is-not-compatible-with-function-implementa
• https://stackoverflow.com/questions/74082800/how-to-define-overloaded-curry-function-in-typescript
• microsoft/TypeScript#16410
• microsoft/TypeScript#10734

std/testing is deprecated. imports should use std/assert instead.

Using generator functions means that an iterable can only be used once. To demonstrate

function* generator() {
  let index = 0;
  while (true) {
    yield index++;
  }
}

const g = generator()

g.next().value // 0
g.next().value // 1
g[Symbol.iterator]().next().value // 2

Instead, methods should be generator functions that return an object with the iterable protocol.

consume all elements, sum it, and get average value.

What are your thoughts on supporting Async iterables/iterators like iter-ops does?

https://deno.land/std/collections/mod.ts
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/

Functions for specific common tasks around collection types like Array and Record. This module is heavily inspired by kotlins stdlib.

TODO

• #10
• ascend
• associateBy
• associateWith
• chunk
• descend
• distinct
• distinctBy
• dropLastWhile
• dropWhile
• findSingle
• firstNotNullishOf
• groupBy
• intersect
• joinToString
• mapNotNullish
• maxBy
• maxOf
• maxWith
• minBy
• minOf
• minWith
• partition
• permutations
• runningReduce
• sample
• slidingWindows
• sortBy
• sumOf
• takeLastWhile
• takeWhile
• union
• unzip
• withoutAll
• zip

libraries like fast-check allows generation of arbitrary testing datas to harden tests further.