reduce, map, filter, take, reduce 중첩 사용
우선 지금까지 만들어 뒀던 함수들은 다음과 같다.
const curry = f =>
(a, ..._) => _.length
? f(a, ..._)
: (..._) => f(a, ..._);
const range = l => {
let i = -1;
const res = [];
while (++i < l) res.push(i);
return res;
};
const map = curry((f, iter) => {
const res = [];
for (const a of iter) res.push(f(a));
return res;
};
const filter = curry((f, iter) => {
const res = [];
for (const a of iter) if (f(a)) res.push(a);
return res;
};
const reduce = curry((f, acc, iter) => {
if (!iter) {
iter = acc[Symbol.iterator]();
acc = iter.next().value;
}
for (const a of iter) {
acc = f(acc, a);
}
return acc
});
const take = curry((l, iter) => {
const res = [];
for (const a of iter) {
res.push(a);
if (res.length === l) return res;
}
return res;
});
const L = {};
L.range = function *(l) {
let i = -1;
while (++i < l) yield i;
};
L.map = curry(function *(f, iter) {
for (const a of iter) {
yield f(a);
}
});
L.filter = curry(function *(f, iter) {
for (const a of iter) {
if (f(a)) yield a;
}
};
const go = (...args) => reduce((a, f) => f(a), args);
const pipe = (...fs) => a => go(a, fs);
이렇게 모든 준비가 완료됐고, 본격적으로 응용해볼 차례이다.
예를 들어 range를 출력하는 함수는 다음과 같다.
go(range(10), log);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
여기에 map을 체이닝할 수도 있다.
go(range(10),
map(n => n + 10),
console.log);
// [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
filter를 체이닝하면 아래와 같다.
go(range(10),
map(n => n + 10),
filter(n => n % 2),
console.log);
// [11, 13, 15, 17, 19]
마지막으로 take까지 붙이면 아래와 같다.
go(range(10),
map(n => n + 10),
filter(n => n % 2),
take(2),
console.log);
// [11, 13]
L.reduce, L.map, L.filter, take, reduce 중첩 사용
이를 게으른 평가를 적용한 함수에서도 동일하게 사용할 수 있다.
go(L.range(10),
L.map(n => n + 10),
L.filter(n => n % 2),
take(2),
console.log);
// [11, 13]
결과는 같으나 둘의 리턴값과 평가되는 것 모두 다 다르다.
둘 간의 차이를 조금 더 분명하게 확인하기 위하여 절차적으로 함수를 분해할 수 있다.
const map = curry((f, iter) => {
let res = [];
iter = iter[Symbol.iterator]();
let cur;
while (!(cur = iter.next()).done) {
const a = cur.value;
res.push(f(a));
}
return res;
};
위의 함수 식은 기존의 for of 문을 대체하는 식이다.
이를 다른 함수에서 적용시킬 수 있다.
const range = l => {
let i = -1;
const res = [];
while (++i < l) res.push(i);
return res;
};
const map = curry((f, iter) => {
const res = [];
iter = iter[Symbol.iterator]();
let cur;
while (!(cur = iter.next()).done) {
const a = cur.value;
res.push(f(a));
}
return res;
};
const filter = curry((f, iter) => {
const res = [];
iter = iter[Symbol.iterator]();
let cur;
while (!(cur = iter.next()).done) {
const a = cur.value;
if (f(a)) res.push(a);
}
return res;
};
const reduce = curry((f, acc, iter) => {
if (!iter) {
iter = acc[Symbol.iterator]();
acc = iter.next().value;
} else {
iter = iter[Symbol.iterator]();
let cur;
while (!(cur = iter.next()).done) {
const a = cur.value;
acc = f(acc, a);
}
return acc
});
const take = curry((l, iter) => {
const res = [];
iter = iter[Symbol.iterator]();
let cur;
while (!(cur = iter.next()).done) {
const a = cur.value;
res.push(a);
if (res.length === l) return res;
}
return res;
});
const L = {};
L.range = function *(l) {
let i = -1;
while (++i < l) yield i;
};
L.map = curry(function *(f, iter) {
iter = iter[Symbol.iterator]();
let cur;
while (!(cur = iter.next()).done) {
const a = cur.value;
yield f(a);
}
});
L.filter = curry(function *(f, iter) {
iter = iter[Symbol.iterator]();
let cur;
while (!(cur = iter.next()).done) {
const a = cur.value;
if (f(a)) yield a;
}
};
이렇게 바꿈으로써 살짝 복잡해 보이지만 실제로 성능은 더 좋아지게 되었다.
순회를 이터레이터로 하면서 조금 더 성능을 높일 수 있었다. 이전보다 점점 더 함수형 프로그래밍에 진척이 있는 것 같다.
출처: 인프런 함수형 프로그래밍과 JavaScript ES6+
'프론트엔드 > JS' 카테고리의 다른 글
[JavaScript] map, filter 계열 함수들이 가지는 결합 법칙, 지연평가의 장점 (0) | 2023.05.05 |
---|---|
[JavaScript] L.range, L.map, L.filter, take의 평가 순서 및 효율성 (0) | 2023.05.03 |
[JavaScript] 제너레이터/이터레이터 프로토콜로 구현하는 지연 평가 (0) | 2023.05.02 |
[JavaScript] take 함수 (2) | 2023.05.02 |
[JavaScript] range와 느긋한 L.range 테스트 (0) | 2023.05.01 |