@b08/functional, seeded from @b08/library-seed, library type: dry

A set of 'functional programming' conversions

mapWith

Creates a function that maps array with provided mapper function.

function itemMapper(a: number): string { // return new value … }

// usually is written like this
function arrayMapper(a: number[]): string[] { return a.map(doSmth); }

// can now write it like this
const arrayMapper = mapWith(itemMapper);

When the mapper function has several arguments, first parameter is element of the array, the rest of the parameters are the same for each array element.

function itemMapper(a: number, b: number): string { // return new value … }

// usually is written like this
function arrayMapper(a: number[], b: number): string[] { return a.map(a1 => itemMapper(a1, b)); }

// alternatively
const arrayMapper = mapWith(itemMapper);

// or just call directly
const result: string[] = mapWith(itemMapper)([1, 2, 3], 4); 

filterWith

Creates a function that filters the array with provided predicate.

function predicate(a: number, b: number): boolean { // return bool … }

// usually is written like this
function arrayFilter(a: number[], b: number): number[] { return a.filter(a1 => predicate(a1, b)); }

// alternatively
const arrayFilter = filterWith(predicate);

// or just call directly
const result: number[] = filterWith(predicate)([1, 2, 3], 4);

filterWithNot / rejectWith

Same as filterWith, but inverts predicate result.

partial

Where it is applicable.

Sometimes you have to use functions having 2 arguments in a one-argument context. for example, here employeeMatches is used like that

export function findEmployeeById(employees: Employee[], id: EmployeeId): Employee {
	return employees.find(employee => employeeMatches(employee, id));
}

function employeeMatches(employee: Employee, id: EmployeeId): boolean {
	return employeeIdEquals(employee.id, id);
}

Suggestion

is to shorten partial application a bit, just like that:

export function findEmployeeById(employees: Employee[], id: EmployeeId): Employee {
	// instead of this
	// return employees.find(employee => employeeMatches(employee, id));
	// write this
	   return employee.find(partial(employeeMatches, id));
	// or this
	   return employee.find(partial2(employeeMatches, id));
}

Here "partial2", means that you fix the target function to having 2 parameters exactly. As well as "partial3" is fixed to 3 and "partial4" to 4 correspondingly. And "partial" has overrides for any amount of arguments in target function up to 4, which is a bit less strict, but it has limitation, you can't predefine all arguments. I could not make safe typing for that case.

Alternatively

Can use lodash _.partialRight, which is a bit longer definition, larger package, and yes, has that defect with unsafe typing for no-arguments return function.