const iterable = {
	[Symbol.iterator]() {
		let i = 3;
		return {
			next() {
				return i == 0 ? { done:true } { value: i--, done:false }
			},
			[Symbol.iterator]() {
				return this // 자기자신을 반환하는 well-formed iterator
			}
		}
	}
};

let iterator = iterable[Symbol.iterator]]();
for (const a of iterator) console.log(a);

const arr2 = [1, 2, 3]
const iter2 = arr2[Symbol.iterator]();
iter2.next();
for (const a of iter2) console.log(a);

const a = [1, 2]
// a[Symbol.iterator] = null; // 역시 iterator가 있기에 전개연산자가 가능하다
console.log(...a, ...[3, 4])

function *gen(){
	yield 1;
	yield 2;
	yield 3;
	yield 4;
}

let iter = gen();
console.log(iter[Symbol.iterator]() == iter]);
console.log(iter.next());

for (const a of gen()) console.log(a);

// 무한히 생성하는 함수
function *infinity(i = 0){
	while(true) yield i++;
}

// iterator를 받아서 l과 동일할 경우 멈추는 로직
function *limit(l, iter){
	for( const a of iter){
		yield a;
		if(a == l) return;
	}
}

let iter3 = infinity();

function *odds(l){
	for(const a of limit(l, infinity(1))){
		if(a % 2) yield a;
		if(a == l) return;
	} 
}

let iter2 = odds(10);
console.log(iter2.next());
console.log(iter2.next());
console.log(iter2.next());
console.log(iter2.next());
console.log(iter2.next());

for (const a of odds(40)) console.log(a);

console.log(...odds(10))
console.log([...odds(10), ...odds(20)]); // 전개 연산자

const [a, b, ...rest] = odds(5); // 구조 분해, 나머지 연산자
console.log(a)
console.log(b)
console.log(rest)

const products = [
  { name: '반팔티', price: 15000 },
  { name: '긴팔티', price: 20000 },
  { name: '핸드폰케이스', price: 15000 },
  { name: '후드티', price: 30000 },
  { name: '바지', price: 25000 }
]

// map 함수를 직접 구현
const map = (f, iter) => {
  let res = [];
  for (const p of iter) {
    res.push(f(p));
  }
  return res
}

let names = []
for (const p of products) {
  names.push(p.name)
}
console.log(names)

console.log(map(p => p.name, products));

let prices = []
for (const p of products) {
  prices.push(p.price)
}

console.log(prices)

// array 처럼 생겼지만 map 사용이 불가능하다. => 유사 배열이기 때문이다.
// Array를 상속 받지 않아서...
console.log(document.querySelectorAll('*').map(el => el.nodeName))

// 이것이 작동하는 이유는 iterable 프로토콜을 따르기 때문이다.
console.log(map(el => el.nodeName, document.querySelectorAll('*')))

console.log([1,2,3]).map(a => a + 1);

function *gen(){
  yield 1;
  yield 2;
  yield 4;
}

console.log(map(a => a + 1, gen()))

let m = new Map();
m.set('a', 10);
m.set('b', 20);

const it = m[Symbol.iterator]();
new Map(map(([k, a]) => [k, a * 2] , m))

const products = [
  { name: '반팔티', price: 15000 },
  { name: '긴팔티', price: 20000 },
  { name: '핸드폰케이스', price: 15000 },
  { name: '후드티', price: 30000 },
  { name: '바지', price: 25000 }
]

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

// let under20000 = [];
// for (const p of products) {
//   if(p.price < 20000) under20000.push(p);
// }
// console.log(...under20000);

console.log(...filter((p) => p.price < 20000, products))

// let over20000 = [];
// for (const p of products) {
//   if(p.price >= 20000) over20000.push(p);
// }
// console.log(...over20000);

console.log(...filter((p) => p.price >= 20000, products))

console.log(filter(n => n % 2, [1, 2, 3, 4]));

const nums = [1, 2, 3, 4, 5]
let total = 0;

for (const n of nums) {
  total = total + n
}
console.log(total)

// ---------------------------

const products = [
  { name: '반팔티', price: 15000 },
  { name: '긴팔티', price: 20000 },
  { name: '핸드폰케이스', price: 15000 },
  { name: '후드티', price: 30000 },
  { name: '바지', price: 25000 }
]

const reduce = (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 add = (a, b) => a + b

console.log(reduce(add, 0, [1, 2, 3, 4, 5])); // 15
console.log(reduce(add, [1, 2, 3, 4, 5])); // 15

console.log(reduce((total_price, product) => total_price + product.price, 0, products));

const products = [
  { name: '반팔티', price: 15000 },
  { name: '긴팔티', price: 20000 },
  { name: '핸드폰케이스', price: 15000 },
  { name: '후드티', price: 30000 },
  { name: '바지', price: 25000 }
]

// map
const map = (f, iter) => {
  let res = [];
  for (const p of iter) {
    res.push(f(p));
  }
  return res
}

// filter
const filter = (f, iter) => {
  let res = [];
  for (const a of iter) {
    if (f(a)) res.push(a);
  }
  return res
}

// reduce
const reduce = (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 add = (a, b) => a + b;

// 가격만 뽑아내기
console.log(reduce(add, map(p => p.price, filter( p => p.price < 20000, products))));
console.log(reduce(add, filter(n => n >= 20000, map( p => p.price, products))));

// reduce
const reduce = (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 go = (...args) => {
  reduce((a, f) => f(a), args)

}

go(
  0,
  a => a + 1,
  a => a + 10,
  a => a + 100,
  console.log
)// 111

// reduce
const reduce = (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 go = (...args) => {
  reduce((a, f) => f(a), args)
}

const add = (a, b) => a + b

go(
  add(0, 1),
  a => a + 10,
  a => a + 100,
  console.log
)// 111

// go는 즉시 평가를 함수한다면, pipe는 함수를 만든다.
// 함수를 반환하는 pipe 함수
const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs)

const f = pipe(
  add,
  a => a + 10,
  a => a + 100,
  console.log
)

console.log(f(0, 1))

// map
const map = (f, iter) => {
  let res = [];
  for (const p of iter) {
    res.push(f(p));
  }
  return res
}

// filter
const filter = (f, iter) => {
  let res = [];
  for (const a of iter) {
    if (f(a)) res.push(a);
  }
  return res
}

// reduce
const reduce = (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 go = (...args) => reduce((a, f) => f(a), args)
const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs)

//---------------------------------------
const products = [
  { name: '반팔티', price: 15000 },
  { name: '긴팔티', price: 20000 },
  { name: '핸드폰케이스', price: 15000 },
  { name: '후드티', price: 30000 },
  { name: '바지', price: 25000 }
]

const add = (a, b) => a + b

go(
  products,
  products => filter(p => p.price < 20000, products),
  products => map(p => p.price, products),
  prices => reduce(add, prices),
  console.log
)

const products = [
  { name: '반팔티', price: 15000 },
  { name: '긴팔티', price: 20000 },
  { name: '핸드폰케이스', price: 15000 },
  { name: '후드티', price: 30000 },
  { name: '바지', price: 25000 }
]

// 인자를 원하는만큼 받았을 때 평가를 해서 리턴한다.
const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);

const mult = curry((a, b) => a * b); 
console.log(mult); // function
console.log(mult(1)(2));

const mult3 = mult(3);
console.log(mult3(10));
console.log(mult3(5));

// 아래와 같이 map, filter, reduce에 curry를 적용함으로써 간결하게 만들 수 있다.
// map
const map = curry((f, iter) => {
  let res = [];
  for (const p of iter) {
    res.push(f(p));
  }
  return res
})

// filter
const filter = curry((f, iter) => {
  let res = [];
  for (const a of iter) {
    if (f(a)) res.push(a);
  }
  return res
})

// reduce
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 go = (...args) => reduce((a, f) => f(a), args)
const add = (a, b) => a + b;

go(
  products,
  filter(p => p.price < 20000),
	map(p => p.price),
  reduce(add),
  console.log
)

const total_price = pipe(
  map(p => p.price),
  reduce(add)
)

const base_total_price = predi => pipe(
  filter(predi),
  total_price
)

go(
  products,
  base_total_price(p => p.price < 20000),
  console.log
)

go(
  products,
  base_total_price(p => p.price >= 20000),
  console.log
)

const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
  // reduce
  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 add = (a, b) => a + b;

  const range = l => {
    let i = -1;
    let res = [];
    while (++i < l) {
      // console.log(i, "range")
      res.push(i)
    }
    return res
  }

  var list = range(4)
  console.log(list)
  console.log(reduce(add, list))

  // 느긋한 L.range
  const L = {};
  L.range = function *(l) {
    let i = -1;
    while (++i < l) {
      // console.log(i, "L.range")
      yield i;
    }
  }

  var list = L.range(4)
  console.log(list)
  console.log(reduce(add, list))

  //----------------------------------------------------------
  // 테스트 진행하기
  function test(name, time, f) {
    console.time(name);
    while(time--) f();
    console.timeEnd(name);
  }

  test('range', 10, () => reduce(add, range(10000)))
  test('L.range', 10, () => reduce(add, L.range(10000)))

const go = (...args) => reduce((a, f) => f(a), args)
  const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
  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 add = (a, b) => a + b;

  const range = l => {
    let i = -1;
    let res = [];
    while (++i < l) {
      // console.log(i, "range")
      res.push(i)
    }
    return res
  }

  // 느긋한 L.range
  const L = {};
  L.range = function *(l) {
    let i = -1;
    while (++i < l) {
      // console.log(i, "L.range")
      yield i;
    }
  }

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

    return res
  })

  console.time('')
  // console.log(take(5, range(1000000)))
  go(
    range(10000),
    take(5),
    reduce(add),
    console.log
  )
  console.timeEnd('')
  console.time('')
  // console.log(take(5, L.range(1000000)))
  go(
    L.range(10000),
    take(5),
    reduce(add),
    console.log
  )
  console.timeEnd('')

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

  var it = L.map(a => a + 10,[1, 2, 3])
  console.log(it.next())

const L = {};
L.filter = function *(f, iter) {
    for (const a of iter) {
      if (f(a)) yield a;
    }
  }
  
  var it = L.filter(a => a % 2, [1, 2, 3, 4])
  console.log([...it])

const go = (...args) => reduce((a, f) => f(a), args)
  const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);

  // map
  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
  })

  // filter
  const filter = curry((f, iter) => {
    let res = [];
    iter = iter[Symbol.iterator]()
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      if (f(a)) res.push(a);
    }
    return res
  })

  // reduce
  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 range = l => {
    let i = -1;
    let res = [];
    while (++i < l) {
      res.push(i)
    }
    return res
  }

  const take = curry((l, iter) => {
    let 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) {
      a = cur.value
      yield f(a);
    }
  })

  L.filter = curry(function* (f, iter) {
    iter = iter[Symbol.iterator]()
    let cur;
    while (!(cur = iter.next()).done) {
      a = cur.value
      if (f(a)) yield a;
    }
  })

  //----------------------------------------

  go(range(10),
    map(n => n + 10),
    filter(n => n % 2),
    take(2),
    console.log)

  go(L.range(10),
    L.map(n => n + 10),
    L.filter(n => n % 2),
    take(2),
    console.log)

// 결과를 만드는 함수 reduce, take
  // reduce는 결과를 만들어 내는 역할
  // const queryStr = obj => go(
  //   obj,
  //   Object.entries,
  //   map(([k, v])=> `${k}=${v}`),
  //   reduce((a, b) => `${a}&${b}`)
  // );

  const queryStr = pipe(
    Object.entries,
    map(([k, v]) => `${k}=${v}`),
    reduce((a, b) => `${a}&${b}`)
  );

  console.log(queryStr({ limit: 10, offset: 10, type: 'notice' }))

L.entries = function *(obj) {
    for (const k in obj) yield [k, obj[k]]
  }

  // 배열에서만 사용되는 join이므로 iterator로 사용이 가능하도록 만듬
  const join = curry((sep = ',', iter) => reduce((a, b) =>`${a}${sep}${b}`, iter))

  const queryStr = pipe(
    L.entries,
    L.map(([k, v]) => `${k}=${v}`),
    function(a){
      console.log(a)
      return a;
    },
    join('&')
  );

  console.log(queryStr({ limit: 10, offset: 10, type: 'notice' }))

  function *b() {
    yield 1;
    yield 2;
    yield 3;
    yield 4;
  }

  console.log(join('-', b()))

const find = curry((f, iter) => go(
    iter, 
    L.filter(f),
    take(1),
    ([a]) => a
  ))

  console.log(find(u => u.age< 30)(users))

  go(
    users,
    L.map(u => u.age),
    find(n => n < 30),
    console.log
  )

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 map = curry(pipe(
    L.map,
    take(Infinity)
  ))

  console.log(map(a => a + 10, L.range(4)))

  const filter = curry((pipe(L.filter, take(Infinity))))

  console.log(filter(a => a > 1, L.range(4)))

// L.flatten
  const takeAll = take(Infinity)
  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;
      }
    }
  }

  var it = L.flatten([[1,2], 3, 4, [5, 6], [7, 8, 9]])
  console.log([...it])
  console.log(take(3, L.flatten([[1,2], 3, 4, [5, 6], [7, 8, 9]])))

  // flatten
  const flatten = pipe(L.flatten, takeAll)
  console.log(flatten([[1,2], 3, 4, [5, 6], [7, 8, 9]]))

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

// yield *을 활용하면 위 코드를 아래와 같이 변경할 수 있습니다. yield *iterable은 for (const val of iterable) yield val; 과 같습니다.
L.flatten = function *(iter) {
  for (const a of iter) {
    if (isIterable(a)) yield *a;
    else yield a;
  }


// L.deepFlat
// 만일 깊은 Iterable을 모두 펼치고 싶다면 아래와 같이 L.deepFlat을 구현하여 사용할 수 있습니다. L.deepFlat은 깊은 Iterable을 펼쳐줍니다.
L.deepFlat = function *f(iter) {
  for (const a of iter) {
    if (isIterable(a)) yield *f(a);
    else yield a;
  }
};
console.log([...L.deepFlat([1, [2, [3, 4], [[5]]]])]);
// [1, 2, 3, 4, 5];

// map과 flatten을 한 것이 flatMap이다.
  // JS 표준에도 있다. 

  L.flatMap = curry(pipe(
    L.map,
    L.flatten
  ))

  const flatMap = curry(pipe(L.map, flatten));

  var it = L.flatMap(a => a, [[1, 2], [5, 6], [7, 8, 9]])
  // var it = L.flatMap(map(a => a * a), [[1, 2], [5, 6], [7, 8, 9]])

  console.log([...it])
  console.log(flatMap(a => a, [[1, 2], [5, 6], [7, 8, 9]]))
  console.log(flatMap(range, [1, 2, 3]))

function add10(a, callback){
	setTimeout(() => callback(a + 10), 1000;
};

add10(5, res => {
	add10(res, res => {
		add10(res, res => {
			console.log(res);
		};
	};
};

// add20은 프로미스를 만들어서 리턴한다.
function add20(a){
	return new Promise(resolve => setTimeout(() => resolve(a + 20), 100));
};

add20(5)
	.then(add20)
	.then(add20)
	.then(console.log);

const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);

const go1 = (a, f) => a instanceof Promise ?  a.then(f) : f(a);

// reduce
const reduce = curry((f, acc, iter) => {
  if (!iter) {
    iter = acc[Symbol.iterator]();
    acc = iter.next().value;
  }else{
    iter = iter[Symbol.iterator]()
  }

  return go1(acc, function recur(acc) {
	  let cur;
		while (!(cur = iter.next()).done) {
		  const a = cur.value;
	    acc = f(acc, a);
			if(acc instanceof Promise) return acc.then(recur);
	  }

	  return acc;
	});
})
const go = (...args) => reduce((a, f) => f(a), args)

go(Promise.resolve(1),
	a => a + 10,
	a => Promise.resolve(a + 100),
	a => Promise.reject('error~~'),
	a => a + 1000,
	a => a + 10000,
	console.log
).catch(a => console.log(a));

Promise.resolve(Promise.resolve(Promise.resolve(1))).then(a => {
	console.log(a);
});

new Promise(resolve => resolve(new Promise(resolve => resolve(1)))).then(console.log);

const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);

// reduce
const reduce = curry((f, acc, iter) => {
  if (!iter) {
    iter = acc[Symbol.iterator]();
    acc = iter.next().value;
  } else {
    iter = iter[Symbol.iterator]()
  }

  return go1(acc, function recur(acc) {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      acc = f(acc, a);
      if (acc instanceof Promise) return acc.then(recur);
    }

    return acc;
  });
})

const go = (...args) => reduce((a, f) => f(a), args)

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

const take = curry((l, iter) => {
  let res = [];
  iter = iter[Symbol.iterator]()
  let cur;
  return function recur() {
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      if (a instanceof Promise) return a.then(
        a => (res.push(a), res).length == l ? res : recur());
      res.push(a);
      if (res.length == l) return res;
    }
    return res
  }();
})


go([Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
  L.map(a => a + 10),
  take(2),
  console.log
)
go([2,3,4],
  L.map(a => Promise.resolve(a + 10)),
  take(2),
  console.log
)

const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);

// reduce
const reduce = curry((f, acc, iter) => {
  if (!iter) {
    iter = acc[Symbol.iterator]();
    acc = iter.next().value;
  } else {
    iter = iter[Symbol.iterator]()
  }

  return go1(acc, function recur(acc) {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      acc = f(acc, a);
      if (acc instanceof Promise) return acc.then(recur);
    }

    return acc;
  });
})

const go = (...args) => reduce((a, f) => f(a), args)

const L = {}

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

const take = curry((l, iter) => {
  let res = [];
  iter = iter[Symbol.iterator]();
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      
      if (a instanceof Promise) {
        return a
        .then(ab => (res.push(ab), res).length == l ? res : recur())
        .catch(e => e == nop ? recur() : Promise.reject(e));
      }
      res.push(a);
      if (res.length == l) return res;
    }
    return res
  }();
})  

const nop = Symbol('nop');

L.filter = curry(function* (f, iter) {
  for (const a of iter) {
    const b = go1(a, f);
    if (b instanceof Promise) yield b.then(c => c ? a : Promise.reject(nop));
    else if (b) yield a
  }
})

go([1, 2, 3, 4, 5, 6],
  L.map(a => Promise.resolve(a * a)),
  L.filter(a => a % 2),
  take(2),
  console.log
);

const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);
const nop = Symbol('nop');

const reduceF = (acc, a, f) => 
  a instanceof Promise ? 
    a.then(a => f(acc, a), e => e == nop ? acc : Promise.reject(e)) : 
    f(acc, a);

const head = iter => go1(take(1, iter), ([h]) => h);
// reduce
const reduce = curry((f, acc, iter) => {
  if (!iter) return reduce(f, head(iter = acc[Symbol.iterator]()), iter);
  
  iter = iter[Symbol.iterator]()
  return go1(acc, function recur(acc) {
    let cur;
    while (!(cur = iter.next()).done) {
      acc = reduceF(acc, cur.value, f);
      if (acc instanceof Promise) return acc.then(recur);
    }
    return acc;
  });
})

const go = (...args) => reduce((a, f) => f(a), args)

const L = {}

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

const take = curry((l, iter) => {
  let res = [];
  iter = iter[Symbol.iterator]();
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      
      if (a instanceof Promise) {
        return a
        .then(ab => (res.push(ab), res).length == l ? res : recur())
        .catch(e => e == nop ? recur() : Promise.reject(e));
      }
      res.push(a);
      if (res.length == l) return res;
    }
    return res
  }();
})  



L.filter = curry(function* (f, iter) {
  for (const a of iter) {
    const b = go1(a, f);
    if (b instanceof Promise) yield b.then(c => c ? a : Promise.reject(nop));
    else if (b) yield a
  }
})

const add = (a, b) => a + b

go([1, 2, 3, 4, 5, 6],
  L.map(a => Promise.resolve(a * a)),
  L.filter(a => Promise.resolve(a % 2)),
  reduce(add),
  console.log
);

const curry = f => (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);
const nop = Symbol('nop');

const reduceF = (acc, a, f) => 
  a instanceof Promise ? 
    a.then(a => f(acc, a), e => e == nop ? acc : Promise.reject(e)) : 
    f(acc, a);

const head = iter => go1(take(1, iter), ([h]) => h);
// reduce
const reduce = curry((f, acc, iter) => {
  if (!iter) return reduce(f, head(iter = acc[Symbol.iterator]()), iter);
  
  iter = iter[Symbol.iterator]()
  return go1(acc, function recur(acc) {
    let cur;
    while (!(cur = iter.next()).done) {
      acc = reduceF(acc, cur.value, f);
      if (acc instanceof Promise) return acc.then(recur);
    }
    return acc;
  });
})

const go = (...args) => reduce((a, f) => f(a), args)

const L = {}

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

const take = curry((l, iter) => {
  let res = [];
  iter = iter[Symbol.iterator]();
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      
      if (a instanceof Promise) {
        return a
        .then(ab => (res.push(ab), res).length == l ? res : recur())
        .catch(e => e == nop ? recur() : Promise.reject(e));
      }
      res.push(a);
      if (res.length == l) return res;
    }
    return res
  }();
})  



L.filter = curry(function* (f, iter) {
  for (const a of iter) {
    const b = go1(a, f);
    if (b instanceof Promise) yield b.then(c => c ? a : Promise.reject(nop));
    else if (b) yield a
  }
})

const add = (a, b) => a + b

go([1, 2, 3, 4, 5, 6],
  L.map(a => new Promise(resolve => setTimeout(() => resolve(a * a), 1000))),
  L.filter(a => Promise.resolve(a % 2)),
  take(2),
  // reduce(add),
  console.log
);

let C = {}

  function noop() { }
  const catchNoop = arr => (arr.forEach(a => a instanceof Promise ? a.catch(noop) : a), arr);

  C.reduce = curry((f, acc, iter) => {
    const iter2 = catchNoop(iter ? [...iter] : [...acc]);
    return iter ? reduce(f, acc, [...iter2]) : reduce(f, [...iter2])
  })

  C.take = curry((l, iter) =>take(l, catchNoop([...iter])));

  const delay500 = a => new Promise(resolve => {
    console.log('hi!');
    setTimeout(() => {
      resolve(a)
    }, 1000);
  })

  console.time()
  go([1, 2, 3, 4, 5, 6, 7, 8, 9],
    L.map(a => delay500(a * a)),
    L.filter(a => delay500(a % 2)),
    L.map(a => delay500(a * a)),
    C.take(2),
    reduce(add),
    log,
    _ => console.timeEnd()
  )

const log = console.log;

const curry = f =>
  (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);

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

const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);

const reduceF = (acc, a, f) =>
  a instanceof Promise ?
    a.then(a => f(acc, a), e => e == nop ? acc : Promise.reject(e)) :
    f(acc, a);

const head = iter => go1(take(1, iter), ([h]) => h);

const reduce = curry((f, acc, iter) => {
  if (!iter) return reduce(f, head(iter = acc[Symbol.iterator]()), iter);

  iter = iter[Symbol.iterator]();
  return go1(acc, function recur(acc) {
    let cur;
    while (!(cur = iter.next()).done) {
      acc = reduceF(acc, cur.value, f);
      if (acc instanceof Promise) return acc.then(recur);
    }
    return acc;
  });
});

const go = (...args) => reduce((a, f) => f(a), args);

const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);

const take = curry((l, iter) => {
  let res = [];
  iter = iter[Symbol.iterator]();
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      if (a instanceof Promise) {
        return a
          .then(a => (res.push(a), res).length == l ? res : recur())
          .catch(e => e == nop ? recur() : Promise.reject(e));
      }
      res.push(a);
      if (res.length == l) return res;
    }
    return res;
  }();
});

const takeAll = take(Infinity);

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 go1(a, f);
  }
});

const nop = Symbol('nop');

L.filter = curry(function* (f, iter) {
  for (const a of iter) {
    const b = go1(a, f);
    if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(nop));
    else if (b) yield a;
  }
});

L.entries = function* (obj) {
  for (const k in obj) yield [k, obj[k]];
};

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

L.deepFlat = function* f(iter) {
  for (const a of iter) {
    if (isIterable(a)) yield* f(a);
    else yield a;
  }
};

L.flatMap = curry(pipe(L.map, L.flatten));

const map = curry(pipe(L.map, takeAll));

const filter = curry(pipe(L.filter, takeAll));

const find = curry((f, iter) => go(
  iter,
  L.filter(f),
  take(1),
  ([a]) => a));

const flatten = pipe(L.flatten, takeAll);

const flatMap = curry(pipe(L.map, flatten));

var add = (a, b) => a + b;

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

let C = {}

  function noop() { }
  const catchNoop = arr => (arr.forEach(a => a instanceof Promise ? a.catch(noop) : a), arr);

  C.reduce = curry((f, acc, iter) => {
    const iter2 = catchNoop(iter ? [...iter] : [...acc]);
    return iter ? reduce(f, acc, [...iter2]) : reduce(f, [...iter2])
  })

  C.take = curry((l, iter) =>take(l, catchNoop([...iter])));
  C.takeAll = C.take(Infinity);

  C.map = curry(pipe(L.map, C.takeAll));
  C.filter = curry(pipe(L.filter, C.takeAll));

  const delay500 = a => new Promise(resolve => {
    console.log('hi!');
    setTimeout(() => {
      resolve(a)
    }, 1000);
  })

  go([1, 2, 3, 4, 5, 6, 7, 8, 9],
    C.map(a => delay500(a * a)),
    log,
  )

  go([1, 2, 3, 4, 5, 6, 7, 8, 9],
    C.filter(a => delay500(a % 2)),
    log,
  )

let C = {}

  function noop() { }
  const catchNoop = arr => (arr.forEach(a => a instanceof Promise ? a.catch(noop) : a), arr);

  C.reduce = curry((f, acc, iter) => {
    const iter2 = catchNoop(iter ? [...iter] : [...acc]);
    return iter ? reduce(f, acc, [...iter2]) : reduce(f, [...iter2])
  })

  C.take = curry((l, iter) =>take(l, catchNoop([...iter])));
  C.takeAll = C.take(Infinity);

  C.map = curry(pipe(L.map, C.takeAll));
  C.filter = curry(pipe(L.filter, C.takeAll));

  const delay500 = (a, name) => new Promise(resolve => {
    console.log(`${name}: ${a}`);
    setTimeout(() => {
      resolve(a)
    }, 1000);
  })

  console.time()
  // go([1, 2, 3, 4, 5],
  //   map(a => delay500(a * a, 'map 1')),
  //   filter(a => delay500(a % 2, 'filter 2')),
  //   map(a => delay500(a * a, 'map 3')),
  //   take(2),
  //   log,
  //   _ => console.timeEnd()
  // )

  // go([1, 2, 3, 4, 5],
  //   L.map(a => delay500(a * a, 'map 1')),
  //   L.filter(a => delay500(a % 2, 'filter 2')),
  //   L.map(a => delay500(a * a, 'map 3')),
  //   take(2),
  //   log,
  //   _ => console.timeEnd()
  // )

  // go([1, 2, 3, 4, 5],
  //   C.map(a => delay500(a * a, 'map 1')),
  //   L.filter(a => delay500(a % 2, 'filter 2')),
  //   L.map(a => delay500(a * a, 'map 3')),
  //   take(2),
  //   log,
  //   _ => console.timeEnd()
  // )

  // go([1, 2, 3, 4, 5],
  //   L.map(a => delay500(a * a, 'map 1')),
  //   L.filter(a => delay500(a % 2, 'filter 2')),
  //   L.map(a => delay500(a * a, 'map 3')),
  //   C.take(2),
  //   log,
  //   _ => console.timeEnd()
  // )

const log = console.log;

const curry = f =>
  (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);

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

const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);

const reduceF = (acc, a, f) =>
  a instanceof Promise ?
    a.then(a => f(acc, a), e => e == nop ? acc : Promise.reject(e)) :
    f(acc, a);

const head = iter => go1(take(1, iter), ([h]) => h);

const reduce = curry((f, acc, iter) => {
  if (!iter) return reduce(f, head(iter = acc[Symbol.iterator]()), iter);

  iter = iter[Symbol.iterator]();
  return go1(acc, function recur(acc) {
    let cur;
    while (!(cur = iter.next()).done) {
      acc = reduceF(acc, cur.value, f);
      if (acc instanceof Promise) return acc.then(recur);
    }
    return acc;
  });
});

const go = (...args) => reduce((a, f) => f(a), args);

const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);

const take = curry((l, iter) => {
  let res = [];
  iter = iter[Symbol.iterator]();
  return function recur() {
    let cur;
    while (!(cur = iter.next()).done) {
      const a = cur.value;
      if (a instanceof Promise) {
        return a
          .then(a => (res.push(a), res).length == l ? res : recur())
          .catch(e => e == nop ? recur() : Promise.reject(e));
      }
      res.push(a);
      if (res.length == l) return res;
    }
    return res;
  }();
});

const takeAll = take(Infinity);

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 go1(a, f);
  }
});

const nop = Symbol('nop');

L.filter = curry(function* (f, iter) {
  for (const a of iter) {
    const b = go1(a, f);
    if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(nop));
    else if (b) yield a;
  }
});

L.entries = function* (obj) {
  for (const k in obj) yield [k, obj[k]];
};

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

L.deepFlat = function* f(iter) {
  for (const a of iter) {
    if (isIterable(a)) yield* f(a);
    else yield a;
  }
};

L.flatMap = curry(pipe(L.map, L.flatten));

const map = curry(pipe(L.map, takeAll));

const filter = curry(pipe(L.filter, takeAll));

const find = curry((f, iter) => go(
  iter,
  L.filter(f),
  take(1),
  ([a]) => a));

const flatten = pipe(L.flatten, takeAll);

const flatMap = curry(pipe(L.map, flatten));

var add = (a, b) => a + b;

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

const C = {};

function noop() {
}

const catchNoop = ([...arr]) =>
  (arr.forEach(a => a instanceof Promise ? a.catch(noop) : a), arr);

C.reduce = curry((f, acc, iter) => iter ?
  reduce(f, acc, catchNoop(iter)) :
  reduce(f, catchNoop(acc)));

C.take = curry((l, iter) => take(l, catchNoop(iter)));

C.takeAll = C.take(Infinity);

C.map = curry(pipe(L.map, C.takeAll));

C.filter = curry(pipe(L.filter, C.takeAll));