📚TIL

day8

지연성(Lazy Evaluation)

• 제때 계산법, 느긋한 평가
• 제너레이터/ 이터레이터 프로토콜을 기반으로 구현
• 지연 평가 : 가장 필요한 순간까지 평가를 미루다 필요한 순간이 되면 해당 코드를 평가하여 값을 만듦
• 엄격한 계산에 비해 효율성이 좋음

range & L.range

• 설정한 길이의 배열 또는 이터레이터를 만드는 함수

 //range
 const range = l => {
 	let i =-1;
    let res = [];
    while(++i < l) res.push(i);
    return res;
 };
 
 //L.range
 const L = {};
 L.range = function *(l){
 	let i = -1;
    while(++i < l) yield i;
 };

take

• 값을 원하는 길이만큼 잘라주는 함수

const take = (l, iter) => {
	let res = [];
    for(const a of iter){
    	res.push(a);
        if(res.length == l) return res;
    }
    return res;
};

L.map & L.filter

• 지연 평가를 하는 map, filter 함수

const L = {};
//L.map
L.map = function *(f, iter){
	for(const a of iter)yield f(a);
};

//L.filter
L.filter = function *(f, iter){
	for(const a of iter) if(f(a)) yield a; 
};

join

• Array.prototype.join보다 높은 다형성을 가진 함수

const join = (sep = ',', iter) =>
	reduce((a, b) => `${a}${sep}${b}`, iter));

L.flatten

• 값을 펼쳐서 반환하는 함수

const L = {};
const isIterable = a => a && a[Symbol.iterator];

L.flatten = function *(iter) =>{
	for(const a of iter){
    	if(isIterable(a))for(const b of a)yield b;
        else yield a;
    }
};

flatMap

• map과 flat을 동시에 사용하는 함수

let arr = [[1, 2], [3, 4], [5, 6, 7]];
L.flatMap = curry(pipe(L.map, L.flatten));
var it = L.flatMap(map(a => a * a), arr);

평가 순서

• 지연 평가를 하는 함수는 일반적인 함수를 실행하는 것과 다른 순서를 지님

//일반 함수 실행
go(range(10),			//1. 0~9까지의 배열 생성
    map(n => n * 2),		//2. 배열 요소에 *2
    filter(n => n %2),		//3. 짝수인 요소로 배열을 걸러냄
    take(2),			//4. 배열의 앞에서부터 2개의 요소만을 가져옴
    log);

//지연 평가 함수 실행
go(L.range(10),			//4. 0~9까지의 이터레이터 생성
    L.map(n => n * 2),		//3. *2를 할 이터레이터를 요청, 5
    L.filter(n => n %2),	//2. 짝수를 판단할 이터레이터를 요청,6
    take(2),			//1. 두가지의 요소를 가져올 이터레이터를 요청.7
    log);

🌊하루를 마치며

지연 평가를 배우면서 더 효율성있게 코드를 짤 수 있는 방법을 배울 수 있었다. 재밌었던 부분은 함수의 평가 순서이다. 일반적인 함수의 실행과 반대로 갔다가 내려오는 부분이 흥미롭게 느껴졌다. 아직 능숙하게 함수를 만들고 사용하는 것이 어렵기 때문에 계속해서 사용해보면서 이에 익숙해지도록 노력해야겠다.
내일은 배운 함수형 프로그래밍을 사용해서 과제를 풀어볼 것이다. 풀이 없이 꼭 해결할 수 있었으면 좋겠다. 화이띵!