Proxy optimization of Array methods. For use with immutable methods. Contains memoized methods. Does not modify the input array.

A lightweight Node.js package that memorizes past computations when providing the same functions as in previous calls. Or any javascript agent.

• memoized methods
• helpers
• static helpers
• benchmark

npm i freezelist

import List from "freezelist";

const animals = List([new Dog, new Cat, new Duck]);
const animals.filter... 

• Creates immutable lists from existing arrays or other iterable objects.
• Supports common list manipulation methods such as concat, filter, find etc.
• All operations return new instances of the list, preserving immutability.
• Memorizes past computations when providing the same functions as in previous calls.
• Uses weak reference memoization.
• Employs B-tree-like optimization for memoization in cases of concat or slice operations on previous computations.
• Utilizes a proxy over Array, hence the behavior is similar to Array.

const testArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const testList = List(testArray);
const lt10 = (value) => value < 10;
const gt10 = (value) => value > 10;
testList.filter(lt10) === testList // true
testList.concat(testArray) === testList.concat(testArray) // true
testList.concat(testArray).slice(testArray.length) === testList // true

testList.filter(gt10) === List([]) // true

var ge5 = (value) => value >= 5;
testList.filter(ge5) === testList.filter((value) => value >= 5) // false
testList.filter(ge5) === testList.filter(ge5) // true
testList.toReversed().toReversed() === testList // true

testList.push // undefined
testList.shift // undefined
testList.pop // undefined
testList.unshift // undefined
testList.splice // undefined
testList.sort // undefined
testList.reverse // undefined

List([]) === List.empty // true

• It is not recommended to use this package if function references constantly change. In such cases, caching does not work effectively. Therefore, weak reference memoization might not behave as expected.

• If function references are constantly changing, it is recommended to use the general method Object.freeze or create/apply another Proxy wrapper.

• All methods are implemented using Array prototypes. If any of the methods do not work, please pay attention to your ES version. Otherwise, install polyfills.

this methods memoized

• findIndex
• findLastIndex
• find
• findLast
• filter
• map
• flatMap
• every
• some
• toReversed
• toSorted
• concat

• findIndex
• findLastIndex
• find
• findLast
• filter
• map
• flatMap
• every
• some
• toReversed
• toSorted
• concat
• slice

var isOdd = (value) => value % 2 === 1;
var filterOdd = List.filter(isOdd);
var stringAll = List.map(String);

var numbers  = [1, 2, 3, 4, 5, 6];
var odds     = filterOdd(numbers) // [1, 3, 5]
var strOdds  = stringAll(odds) // ["1", "3", "5"]
var strings  = stringAll(numbers) // ["1", "2", "3", "4", "5", "6"]

var is5Str = (value) => value === "5";
List.find(is5Str)(filterOdd(stringAll(numbers))) // "5"
List.some(is5Str)(filterOdd(stringAll(numbers))) // true

var isString = (value) => typeof value === "string";
var someString = List.some(isString);
someString(numbers) // false
someString(strings) // true

var concat123 = List.concat([1, 2, 3]);
var everyString = List.every(isString);
everyString(numbers) // false
everyString(strings) // true
var mix = concat123(strings); // [1, 2, 3, "1", "2", "3", "4", "5", "6"]
everyString(mix) // false

• The library contains several functions for memoization. You can apply them if necessary.

import memoWeak from "freezelist/memoWeak"

The memoWeak function is similar to memoizeWeak but additionally memoizes the input function itself. This means that if the same function is passed to memoWeak again, it will return the same memoized version of that function.

var find = (call) => (values) => values.find(call);
var findMemo = memoWeak(find);
var identity = value => value
findMemo(identity) === findMemo(identity); // true
memoWeak(find) === memoWeak(find); // true

import memo from "freezelist/memo"

The memo function is similar to memoize but additionally memoizes the parameter of the function. This means that if the same parameter is passed to memo again, it will return the same memoized result for that parameter.

var add = (y) => (x) => x + y;
var addMemo = memo(add);
addMemo === memo(add) // true
addMemo(1)(2) // 3
addMemo(1) === addMemo(1) // true
addMemo(1) === addMemo(2) // false

import memoizeWeak from "freezelist/memoizeWeak";

The memoizeWeak function behaves similarly to memoize but utilizes weak references for caching, enabling efficient memory management.

var find = (call) => (values) => values.find(call);
var findMemo = memoizeWeak(find);
var identity = value => value
findMemo(identity) === findMemo(identity); // true
memoizeWeak(find) === memoizeWeak(find); // false

import memoize from "freezelist/memoize";

This function is a higher-order function that performs memoization, a technique used to cache the results of expensive function calls.

var inc = (next) => console.log("incrementing") || next++;
var memoInc = memoize(inc);
memoInc(2); // 3 | console -> incrementing
memoInc(2); // 3
memoInc(2); // 3
memoInc(3); // 4 | console -> incrementing
memoInc(3); // 4
memoInc(2); // 3
memoInc(1); // 2 | console -> incrementing

var add = (next) => (value) => next + value;
var addMemo = memoize((value) => add(value));
addMemo(1) === addMemo(1); // true

import once from "freezelist/once"

The once function memoizes the computation once and consistently returns the same computed value thereafter.

var add = (y) => (x) => x + y;
var addOnce = once(add);
addOnce(1)(2) // 3
addOnce(2)(2) // 3
addOnce(3)(2) // 3
addOnce(2)(3) // 4
addOnce(3)(3) // 4
addOnce(4)(4) // 5

import pure from "freezelist/pure"

The pure function utilizes the body of the function as a key. If the function has already been created, it returns the same function. Caution: Do not use with side effects.

pure((value) => value + 1) === pure((value) => value + 1) // true
pure((x) => x + 1) === pure((y) => y + 1) // false

import always from "freezelist/always"

always: Exports functions that always return a specified value, regardless of the input argument.

var T = always(true);

T() // true
T(false) // true
T(true) // true

var F = always(false);

F() // false
F(false) // false
F(true) // false

import T from "freezelist/T"

T: Exports a function that always returns true.

T() // true
T(false) // true
T(true) // true

import F from "freezelist/F"

F: Exports a function that always returns false.

F() // false
F(false) // false
F(true) // false

Benefits of Usage Illustrated with an Example.

Array benchmark (small is better)

List benchmark (small is better)

However, there is also a downside to using different references. List benchmark (small is better)

For your own testing, you can review the benchmark.js file located in the library folder.