Iterable Functions

Really simple functions for working with native array types, inspired by F#'s Array module design.

Features

• Full type-safety with TypeScript
• Zero dependency
• Pure functions
• Non-primative poluting
• Chainable functions

Installation

Add package using NPM or yarn

npm i --save array-fns

yarn add array-fns

You can import the top level modules directly:

import { groupBy } from 'array-fns'

Examples

Calculating primes lazily with iterators can either be done by calling each of the basic functions:

import { count, init, map, filter } from '../src/array-fns'

const range = init({ from: 1, to: 100 })
const mapped = map(range, (x) => ({
  x,
  factors: filter(init({ from: 1, to: x }), (y) => x % y === 0),
}))
const filtered = filter(mapped, (num) => count(num.factors) === 2)
const primes = map(filtered, (num) => num.x)

You can also utilise the chain methods to unwrap nested function calls:

import { initChain } from 'array-fns'

const primes = initChain({ from: 1, to: 100 })
  .map((x) => ({
    x,
    factors: initChain({ from: 1, to: x }).filter((y) => x % y === 0),
  }))
  .filter((num) => num.factors.count() === 2)
  .map((num) => num.x)
  .toArray()

for (const prime of primes) {
  console.log(prime)
}

Grouping numbers into odd and even buckets

import { initChain } from 'array-fns'

const oddAndEven = initChain({ from: 1, to: 25 })
  .groupBy((i) => (i % 2 === 0 ? 'even' : 'odd'))
  .toArray()

NPM scripts

• yarn test: Run test suite
• yarn start: Run yarn build in watch mode
• yarn test:watch: Run test suite in interactive watch mode
• yarn test:prod: Run linting and generate coverage
• yarn build: Generate bundles and typings, create docs
• yarn lint: Lints code
• yarn commit: Commit using conventional commit style (husky will tell you to use it if you haven't :wink:)