├── .idea
    ├── .gitignore
    ├── codeStyles
    │   └── codeStyleConfig.xml
    ├── functional-javascript-01.iml
    ├── inspectionProfiles
    │   └── Project_Default.xml
    ├── modules.xml
    └── vcs.xml
├── 01. 함수형 자바스크립트 기본기
    ├── 1.html
    └── 2.html
├── 02. ES6에서의 순회와 이터러블 이터레이터 프로토콜
    └── index.html
├── 03. 제너레이터와 이터레이터
    └── index.html
├── 04. map, filter, reduce
    ├── 1
    │   └── 1. index.html
    └── 2
    │   ├── html
    │       └── 2.html
    │   └── lib
    │       └── fx.js
├── 05. 코드를 값으로 다루어 표현력 높이기
    └── 1
    │   ├── html
    │       └── 1.html
    │   └── lib
    │       └── fx.js
├── 06. HTML 출력해보기
    └── 1
    │   ├── html
    │       └── 1.html
    │   └── lib
    │       └── fx.js
├── 07. 지연성 1, 8. 지연성 2
    ├── 1
    │   ├── html
    │   │   └── 1.html
    │   └── lib
    │   │   └── fx.js
    ├── 2
    │   ├── html
    │   │   └── 2.html
    │   └── lib
    │   │   └── fx.js
    ├── 3
    │   ├── html
    │   │   └── 1.html
    │   └── lib
    │   │   └── fx.js
    └── 4
    │   ├── html
    │       ├── 1.html
    │       └── yield...md
    │   └── lib
    │       └── fx.js
├── 09. 비동기 동시성 프로그래밍
    └── 1
    │   ├── html
    │       ├── 1-1.html
    │       ├── 1-2.html
    │       └── 1-3.html
    │   └── lib
    │       └── fx.js
├── 10. 비동기 동시성 프로그래밍 2
    └── 1
    │   ├── html
    │       ├── 1-1.html
    │       └── 1-2.html
    │   └── lib
    │       └── fx.js
├── 11. 비동기 동시성 프로그래밍 3
    └── 1
    │   ├── html
    │       └── 1-1.html
    │   └── lib
    │       └── fx.js
├── README.md
├── fx.js
├── index.js
└── test
    └── index.js


/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # 디폴트 무시된 파일
2 | /shelf/
3 | /workspace.xml
4 | # 에디터 기반 HTTP 클라이언트 요청
5 | /httpRequests/
6 | 


--------------------------------------------------------------------------------
/.idea/codeStyles/codeStyleConfig.xml:
--------------------------------------------------------------------------------
1 | <component name="ProjectCodeStyleConfiguration">
2 |   <state>
3 |     <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
4 |   </state>
5 | </component>


--------------------------------------------------------------------------------
/.idea/functional-javascript-01.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="WEB_MODULE" version="4">
 3 |   <component name="NewModuleRootManager">
 4 |     <content url="file://$MODULE_DIR$">
 5 |       <excludeFolder url="file://$MODULE_DIR$/.tmp" />
 6 |       <excludeFolder url="file://$MODULE_DIR$/temp" />
 7 |       <excludeFolder url="file://$MODULE_DIR$/tmp" />
 8 |     </content>
 9 |     <orderEntry type="inheritedJdk" />
10 |     <orderEntry type="sourceFolder" forTests="false" />
11 |   </component>
12 | </module>


--------------------------------------------------------------------------------
/.idea/inspectionProfiles/Project_Default.xml:
--------------------------------------------------------------------------------
1 | <component name="InspectionProjectProfileManager">
2 |   <profile version="1.0">
3 |     <option name="myName" value="Project Default" />
4 |     <inspection_tool class="SassScssResolvedByNameOnly" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
5 |   </profile>
6 | </component>


--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/.idea/functional-javascript-01.iml" filepath="$PROJECT_DIR$/.idea/functional-javascript-01.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/01. 함수형 자바스크립트 기본기/1.html:
--------------------------------------------------------------------------------
 1 | <script>const log = console.log;</script>
 2 | 
 3 | # 평가
 4 | - 코드가 계산(Evaluation) 되어 값을 만드는 것
 5 | 
 6 | # 일급
 7 | - 값으로 다룰 수 있다.
 8 | - 변수에 담을 수 있다.
 9 | - 함수의 인자로 사용될 수 있다.
10 | - 함수의 결과로 사용될 수 있다.
11 | 
12 | <script>
13 |   const a = 10;
14 |   const add10 = a => a + 10;
15 |   const r = add10(a);
16 |   log(r); // 20
17 | </script>
18 | 
19 | # 일급 함수
20 | - 함수를 값으로 다룰 수 있다.
21 | - 조합성과 추상화의 도구
22 | 
23 | <script>
24 |   const add5 = a => a + 5;
25 |   log(add5); // a => a + 5
26 |   log(add5(5)); // 10
27 | 
28 |   // 함수 실행 시 함수를 리턴
29 |   const f1 = () => () => 1;
30 |   log(f1()); // () => 1
31 | 
32 |   const f2 = f1();
33 |   log(f2); // () => 1
34 |   log(f2()); // 1
35 | 
36 |   const f3 = () => 1
37 |   console.log(f3) // () => 1
38 | </script>
39 | 


--------------------------------------------------------------------------------
/01. 함수형 자바스크립트 기본기/2.html:
--------------------------------------------------------------------------------
 1 | <script>const log = console.log</script>
 2 | 
 3 | # 일급 함수
 4 | - 함수가 값으로 다뤄질 수 있다.
 5 | 
 6 | # 고차 함수
 7 | - 함수를 값으로 다루는 함수
 8 | 
 9 | ## 함수를 인자로 받아서 실행하는 함수
10 | - apply1
11 | - times
12 | 
13 | <script>
14 |   const apply1 = f => f(1);
15 |   const add2 = a => a + 2;
16 |   /**
17 |    * apply1(add2)
18 |    * apply1(a => a + 2)
19 |    * (a => a + 2)(1)
20 |    * 1 + 2
21 |    * 3
22 |    */
23 |   log(apply1(add2));
24 | 
25 |   /**
26 |    * apply1(a => a - 1)
27 |    * (a => a - 1)(1)
28 |    * 1 - 1
29 |    * 0
30 |    */
31 |   log(apply1(a => a - 1));
32 | 
33 |   const times = (f, n) => {
34 |     let i = -1;
35 |     while (++i < n) f(i);
36 |   };
37 | 
38 |   times(log, 3); // 0 1 2
39 | 
40 |   times(a => log(a + 10), 3); // a 값에 1, 2, 3이 들어가서 11, 12, 13이 출력
41 | </script>
42 | 
43 | ## 함수를 만들어 리턴하는 함수 (클로저를 만들어 리턴하는 함수)
44 | - addMaker
45 | 
46 | <script>
47 |   /**
48 |    * addMaker는 함수를 return하는 함수
49 |    * 클로저를 만들어 리턴하기 때문에 a의 값을 기억하고 있다.
50 |    * */
51 |   const addMaker = a => b => a + b;
52 |   const add10 = addMaker(10);
53 |   /**
54 |    * add10(5)
55 |    * addMaker(10)(5)
56 |    * (a => b => a + b)(10)(5)
57 |    * (b => 10 + b)(5) => 위에서 사용된 a 값을 기억
58 |    * 10 + 5
59 |    */
60 |   log(add10(5));
61 |   log(add10(10));
62 | </script>
63 | 


--------------------------------------------------------------------------------
/02. ES6에서의 순회와 이터러블 이터레이터 프로토콜/index.html:
--------------------------------------------------------------------------------
  1 | <script>const log = console.log;</script>
  2 | 
  3 | ## 기존과 달라진 ES6에서의 리스트 순회
  4 | - for i++
  5 | - for of
  6 | 
  7 | <script>
  8 |   const list = [1, 2, 3];
  9 |   for (var i = 0; i < list.length; i++) {
 10 |     // log(list[i]);
 11 |   }
 12 |   const str = 'abc';
 13 |   for (var i = 0; i < str.length; i++) {
 14 |     // log(str[i]);
 15 |   }
 16 |   for (const a of list) {
 17 |     // log(a);
 18 |   }
 19 |   for (const a of str) {
 20 |     // log(a);
 21 |   }
 22 | </script>
 23 | 
 24 | ### Array를 통해 알아보기
 25 | 
 26 | <script>
 27 |   log('Arr -----------');
 28 |   const arr = [1, 2, 3];
 29 |   console.log(arr[Symbol.iterator]) // f values() { [native code] }
 30 | 
 31 |   /**
 32 |    * iterator를 null로 바꿔버리면 for of문을 사용할 수 없다.
 33 |    * TypeError: arr is not iterable
 34 |    */
 35 |   // arr[Symbol.iterator] = null;
 36 |   for (const a of arr) log(a);
 37 | 
 38 |   let iter1 = arr[Symbol.iterator]();
 39 |   console.log(iter1.next()); // {value: 1, done: false}
 40 |   for (const a of iter1) log(a); // 2 3
 41 | </script>
 42 | 
 43 | ### Set을 통해 알아보기
 44 | 
 45 | <script>
 46 |   log('Set -----------');
 47 |   const set = new Set([1, 2, 3]);
 48 |   /**
 49 |    * index로 접근은 불가는 하나 for문을 통해 순회는 가능
 50 |    * for문을 통해 순회할 때는 Symbol.iterator를 통해 순회
 51 |    */
 52 |   console.log(set[0], set[1], set[2]); // undefined undefined undefined
 53 |   for (const a of set) log(a); // 1 2 3
 54 | </script>
 55 | 
 56 | ### Map을 통해 알아보기
 57 | 
 58 | <script>
 59 |   log('Map -----------');
 60 |   const map = new Map([['a', 1], ['b', 2], ['c', 3]]);
 61 |   for (const a of map.keys()) log(a); // a b c
 62 |   for (const a of map.values()) log(a); // 1 2 3
 63 |   for (const a of map.entries()) log(a); // ['a', 1] ['b', 2] ['c', 3]
 64 |   console.clear();
 65 | </script>
 66 | 
 67 | ## 이터러블/이터레이터 프로토콜
 68 | - 이터러블: 이터레이터를 리턴하는 [Symbol.iterator]() 를 가진 값
 69 | - 이터레이터: { value, done } 객체를 리턴하는 next() 를 가진 값
 70 | - 이터러블/이터레이터 프로토콜: 이터러블을 for...of, 전개 연산자 등과 함께 동작하도록한 규약
 71 | 
 72 | ### 사용자 정의 이터러블을 통해 알아보기
 73 | 
 74 | <script>
 75 |   const iterable = {
 76 |     [Symbol.iterator]() {
 77 |       let i = 3;
 78 |       return {
 79 |         next() {
 80 |           return i == 0 ? {done: true} : {value: i--, done: false};
 81 |         },
 82 |         // 자기 자신을 return 하도록
 83 |         [Symbol.iterator]() {
 84 |           return this;
 85 |         }
 86 |       }
 87 |     }
 88 |   };
 89 |   let iterator = iterable[Symbol.iterator]();
 90 |   iterator.next();
 91 |   iterator.next();
 92 |   // log(iterator.next());
 93 |   // log(iterator.next());
 94 |   // log(iterator.next());
 95 |   for (const a of iterator) log(a);
 96 | 
 97 |   const arr2 = [1, 2, 3];
 98 |   let iter2 = arr2[Symbol.iterator]();
 99 |   iter2.next();
100 |   log(iter2[Symbol.iterator]() == iter2); // true => Symbol.iterator는 자기 자신을 return하기 때문
101 |   for (const a of iter2) log(a);
102 | 
103 |   for (const a of document.querySelectorAll('*')) log(a);
104 |   const all = document.querySelectorAll('*');
105 |   let iter3 = all[Symbol.iterator]();
106 |   log(iter3.next());
107 |   log(iter3.next());
108 |   log(iter3.next());
109 | </script>
110 | 
111 | ## 전개 연산자
112 | 
113 | <script>
114 |   console.clear();
115 |   const a = [1, 2];
116 |   // a[Symbol.iterator] = null;
117 |   log([...a, ...arr, ...set, ...map.keys()]);
118 | </script>
119 | 


--------------------------------------------------------------------------------
/03. 제너레이터와 이터레이터/index.html:
--------------------------------------------------------------------------------
  1 | <script>const log = console.log;</script>
  2 | 
  3 | # 제너레이터/이터레이터
  4 | - 제너레이터: 이터레이터이자 이터러블을 생성하는 함수
  5 | 
  6 | 제너레이터를 통해 어떤 값도 순회하게 만들 수 있음
  7 | 
  8 | <script>
  9 |   function *gen() {
 10 |     /**
 11 |      * yield
 12 |      * - 값 반환: 제너레이터 함수의 실행을 일시 중지하고, 특정 값을 호출자에게 반환
 13 |      * - 상태 저장: 제너레이트 함수는 yield를 만날 때 까지 실행되며, 그 지점에서 일시 중지되어 상태를 저장
 14 |      *      그 이후 next() 메서드를 호출하면 저장된 상태부터 다시 실행
 15 |      * */
 16 |     yield 1;
 17 |     if (false) yield 2;
 18 |     yield 3;
 19 |   }
 20 | 
 21 | 
 22 |   let iter = gen();
 23 |   log(iter[Symbol.iterator]() == iter); // true
 24 |   log(iter.next()); // {value: 1, done: false}
 25 |   log(iter.next()); // {value: 3, done: false} => yield 2가 실행되지 않았기 때문에
 26 |   log(iter.next()); // {value: undefined, done: true}
 27 | 
 28 |   for (const a of gen()) log(a);
 29 |   console.clear();
 30 | </script>
 31 | 
 32 | # odds
 33 | 
 34 | <script>
 35 |   function *infinity(i = 0) {
 36 |     while (true) yield i++;
 37 |   }
 38 | 
 39 |   // 기본적인 odd 제너레이터
 40 |   // function *odds(l) {
 41 |   //     for (let i = 0; i < l; i++) {
 42 |   //       if (i % 2) yield i;
 43 |   //     }
 44 |   // }
 45 | 
 46 | 
 47 |   // limit을 이용한 odd 제너레이터
 48 |   // function *odds(l) {
 49 |   //     for (const a of infinity(1)) {
 50 |   //         if (a % 2) yield a;
 51 |   //         if (a === l) return;
 52 |   //     }
 53 |   // }
 54 | 
 55 |   /**
 56 |    * limit
 57 |    * - 제너레이터를 받아서 l까지만 순회하도록 제한
 58 |    * */
 59 |   function *limit(l, iter) {
 60 |     for (const a of iter) {
 61 |       yield a;
 62 |       if (a === l) return;
 63 |     }
 64 |   }
 65 | 
 66 |   function *odds(l) {
 67 |     for (const a of limit(l, infinity(1))) {
 68 |       if (a % 2) yield a;
 69 |     }
 70 |   }
 71 | 
 72 |   let iter2 = odds(10);
 73 |   log(iter2.next());
 74 |   log(iter2.next());
 75 |   log(iter2.next());
 76 |   log(iter2.next());
 77 |   log(iter2.next());
 78 |   log(iter2.next());
 79 |   log(iter2.next());
 80 | 
 81 |   for (const a of odds(40)) log(a); // 1~40까지의 홀수 출력
 82 | 
 83 |   console.clear();
 84 | </script>
 85 | 
 86 | # for of, 전개 연산자, 구조 분해, 나머지 연산자
 87 | 
 88 | <script>
 89 |   log(...odds(10));
 90 |   log([...odds(10), ...odds(20)]);
 91 | 
 92 |   log(...odds(5)) // 1 3 5
 93 | 
 94 |   const [head, ...tail] = odds(5);
 95 |   log(head); // 1
 96 |   log(tail); // [3, 5]
 97 | 
 98 |   const [a, b, ...rest] = odds(10);
 99 |   log(a); // 1
100 |   log(b); // 3
101 |   log(rest); // [5, 7, 9]
102 | </script>
103 | 


--------------------------------------------------------------------------------
/04. map, filter, reduce/1/1. index.html:
--------------------------------------------------------------------------------
  1 | <script>const log = console.log;</script>
  2 | 
  3 | <script>
  4 |   const products = [
  5 |     {name: '반팔티', price: 15000},
  6 |     {name: '긴팔티', price: 20000},
  7 |     {name: '핸드폰케이스', price: 15000},
  8 |     {name: '후드티', price: 30000},
  9 |     {name: '바지', price: 25000}
 10 |   ];
 11 | </script>
 12 | 
 13 | 
 14 | # map
 15 | 
 16 | <script>
 17 |   const map = (f, iter) => {
 18 |     let res = [];
 19 |     for (const a of iter) {
 20 |       res.push(f(a));
 21 |     }
 22 |     return res;
 23 |   };
 24 | 
 25 |   // let names = [];
 26 |   // for (const p of products) {
 27 |   //   names.push(p.name);
 28 |   // }
 29 |   // log(names);
 30 | 
 31 |   log(map(p => p.name, products));
 32 | 
 33 |   // let prices = [];
 34 |   // for (const p of products) {
 35 |   //   prices.push(p.price);
 36 |   // }
 37 |   // log(prices);
 38 | 
 39 |   log(map(p => p.price, products));
 40 | 
 41 | </script>
 42 | 
 43 | # 이터러블 프로토콜을 따른 map의 다형성
 44 | 
 45 | <script>
 46 |   log([1, 2, 3].map(a => a + 1)); // [2, 3, 4]
 47 | 
 48 |   // document.querySelectorAll('*').map(el => el.nodeName); // Error
 49 |   // console.log(document.querySelectorAll('*').map); // undefined => 순회 가능할 것 같으나 map 메서드가 없음
 50 | 
 51 |   const it = document.querySelectorAll('*')[Symbol.iterator]();
 52 |   console.log(it) // ArrayIterator{}
 53 | 
 54 |   /**
 55 |    * document.querySelectorAll('*')는 이터러블 프로토콜을 따르고 있고,
 56 |    * 위에서 생성한 map 함수는 이터러블 프로토콜을 따르는 for-of 구문을 사용하기 때문에 순회 가능
 57 |    */
 58 |   log(map(el => el.nodeName, document.querySelectorAll('*'))); // ['HTML', 'HEAD', 'META', ...]
 59 |   // log(it.next());
 60 |   // log(it.next());
 61 |   // log(it.next());
 62 |   // log(it.next());
 63 |   // log(it.next());
 64 | 
 65 |   function* gen() {
 66 |     yield 2;
 67 |     if (false) yield 3;
 68 |     yield 4;
 69 |   }
 70 | 
 71 |   log(map(a => a * a, gen())); // [4, 16]
 72 | 
 73 |   let m = new Map();
 74 |   m.set('a', 10);
 75 |   m.set('b', 20);
 76 |   console.log(m) // Map { 'a' => 10, 'b' => 20 }
 77 |   log(new Map(map(([k, a]) => [k, a * 2], m))); // Map { 'a' => 20, 'b' => 40 } => 값에 2를 곱하게 됨
 78 | 
 79 |   console.clear();
 80 | </script>
 81 | 
 82 | 
 83 | # filter
 84 | 
 85 | <script>
 86 |   const filter = (f, iter) => {
 87 |     let res = [];
 88 |     for (const a of iter) {
 89 |       if (f(a)) res.push(a);
 90 |     }
 91 |     return res;
 92 |   };
 93 | 
 94 |   // let under20000 = [];
 95 |   // for (const p of products) {
 96 |   //   if (p.price < 20000) under20000.push(p);
 97 |   // }
 98 |   // log(...under20000);
 99 | 
100 |   log(...filter(p => p.price < 20000, products));
101 | 
102 |   // let over20000 = [];
103 |   // for (const p of products) {
104 |   //   if (p.price >= 20000) over20000.push(p);
105 |   // }
106 |   // log(...over20000);
107 | 
108 |   log(...filter(p => p.price >= 20000, products));
109 | 
110 |   log(filter(n => n % 2, [1, 2, 3, 4])); // [1, 3]
111 | 
112 |   log(filter(n => n % 2, function* () {
113 |     yield 1;
114 |     yield 2;
115 |     yield 3;
116 |     yield 4;
117 |     yield 5;
118 |   }())); // [1, 3, 5]
119 | 
120 |   console.clear();
121 | </script>
122 | 
123 | # reduce
124 | 
125 | <script>
126 |   const nums = [1, 2, 3, 4, 5];
127 | 
128 |   let total = 0;
129 |   for (const n of nums) {
130 |     total = total + n;
131 |   }
132 |   log(total);
133 | 
134 |   const reduce = (f, acc, iter) => {
135 |     if (!iter) {
136 |       iter = acc[Symbol.iterator]();
137 |       // 1번째 값으로 초기화
138 |       acc = iter.next().value;
139 |     }
140 |     for (const a of iter) {
141 |       acc = f(acc, a);
142 |     }
143 |     return acc;
144 |   };
145 | 
146 |   const add = (a, b) => a + b;
147 | 
148 |   log(reduce(add, 0, [1, 2, 3, 4, 5]));
149 |   // 15
150 | 
151 |   log(add(add(add(add(add(0, 1), 2), 3), 4), 5));
152 |   // 15
153 | 
154 |   log(reduce(add, [1, 2, 3, 4, 5]));
155 |   // 15
156 | 
157 |   // console.clear();
158 | </script>
159 | 
160 | <script>
161 |   /**
162 |    * acc 가 처음에 0으로 설정되고
163 |    * acc = (0, product.price) => 0 + product.price 로 설정되며 값이 누적된다
164 |    */
165 |   log(
166 |     reduce(
167 |       (total_price, product) => total_price + product.price,
168 |       0,
169 |       products));
170 | </script>
171 | 


--------------------------------------------------------------------------------
/04. map, filter, reduce/2/html/2.html:
--------------------------------------------------------------------------------
 1 | <script src="../lib/fx.js"></script>
 2 | 
 3 | <script>
 4 |   const products = [
 5 |     {name: '반팔티', price: 15000},
 6 |     {name: '긴팔티', price: 20000},
 7 |     {name: '핸드폰케이스', price: 15000},
 8 |     {name: '후드티', price: 30000},
 9 |     {name: '바지', price: 25000}
10 |   ];
11 | 
12 |   const add = (a, b) => a + b;
13 | 
14 |   // price가 20000 미만인 상품들의 가격 총합
15 |   log(
16 |     reduce(
17 |       add,
18 |       map(p => p.price,
19 |         filter(p => p.price < 20000, products))));
20 | 
21 |   // price가 20000 이상인 상품들의 가격 총합
22 |   log(
23 |     reduce(
24 |       add,
25 |       filter(n => n >= 20000,
26 |         map(p => p.price, products))));
27 | </script>
28 | 


--------------------------------------------------------------------------------
/04. map, filter, reduce/2/lib/fx.js:
--------------------------------------------------------------------------------
 1 | const log = console.log;
 2 | 
 3 | const map = (f, iter) => {
 4 |   let res = [];
 5 |   for (const a of iter) {
 6 |     res.push(f(a));
 7 |   }
 8 |   return res;
 9 | };
10 | 
11 | const filter = (f, iter) => {
12 |   let res = [];
13 |   for (const a of iter) {
14 |     if (f(a)) res.push(a);
15 |   }
16 |   return res;
17 | };
18 | 
19 | const reduce = (f, acc, iter) => {
20 |   if (!iter) {
21 |     iter = acc[Symbol.iterator]();
22 |     acc = iter.next().value;
23 |   }
24 |   for (const a of iter) {
25 |     acc = f(acc, a);
26 |   }
27 |   return acc;
28 | };
29 | 


--------------------------------------------------------------------------------
/05. 코드를 값으로 다루어 표현력 높이기/1/html/1.html:
--------------------------------------------------------------------------------
  1 | <script src="../lib/fx.js"></script>
  2 | 
  3 | <script>
  4 |   const products = [
  5 |     {name: '반팔티', price: 15000},
  6 |     {name: '긴팔티', price: 20000},
  7 |     {name: '핸드폰케이스', price: 15000},
  8 |     {name: '후드티', price: 30000},
  9 |     {name: '바지', price: 25000}
 10 |   ];
 11 | 
 12 |   const add = (a, b) => a + b;
 13 | 
 14 |   log(
 15 |     reduce(
 16 |       add,
 17 |       map(p => p.price,
 18 |         filter(p => p.price < 20000, products))));
 19 |   console.clear();
 20 | </script>
 21 | 
 22 | # 코드를 값으로 다루어 표현력 높이기
 23 | 
 24 | ## go, pipe
 25 | 
 26 | <script>
 27 |   // 첫번째 인자를 그 다음 인자인 함수에 적용하여 값을 반환하는 과정을 반복
 28 |   const go = (...args) => reduce((a, f) => f(a), args);
 29 | 
 30 |   // 함수를 reudce로 연속적으로 실행, pipe는 함수를 return
 31 |   const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
 32 | 
 33 |   go(
 34 |     add(0, 1), // 1
 35 |     a => a + 10, // 11
 36 |     a => a + 100, // 111
 37 |     log);
 38 |   // 111
 39 | 
 40 |   const f = pipe(
 41 |     (a, b) => a + b,
 42 |     a => a + 10,
 43 |     a => a + 100);
 44 | 
 45 |   log(f(0, 1)); // 111
 46 | 
 47 |   console.clear();
 48 | </script>
 49 | 
 50 | <script>
 51 |   log(
 52 |     reduce(
 53 |       add,
 54 |       map(p => p.price,
 55 |         filter(p => p.price < 20000, products))));
 56 | 
 57 |   go(
 58 |     products,
 59 |     products => filter(p => p.price < 20000, products), // 20000 미만인 상품들
 60 |     products => map(p => p.price, products), // 20000 미만인 상품들의 가격
 61 |     prices => reduce(add, prices), // 20000 미만인 상품들의 가격 총합
 62 |     log);
 63 | 
 64 |   /**
 65 |    * 밑에서 다루는 내용이지만 curry를 사용해 filter, map, reduce를 mapping 해서 가능
 66 |    * 인자를 하나 받으면 이후에 받을 인자를 받아서 실행하는 함수를 return
 67 |    */
 68 |   go(
 69 |     products,
 70 |     products => filter(p => p.price < 20000)(products),
 71 |     products => map(p => p.price)(products),
 72 |     products => reduce(add)(products),
 73 |     log);
 74 | 
 75 |   // products를 받아 다시 products를 받는 다는 내용을 지운 코드
 76 |   go(
 77 |     products,
 78 |     filter(p => p.price < 20000),
 79 |     map(p => p.price),
 80 |     reduce(add),
 81 |     log);
 82 | 
 83 |   console.clear();
 84 | </script>
 85 | 
 86 | ## curry
 87 | 
 88 | <script>
 89 |   // 함수를 받아서 함수를 return 
 90 |   // 인자가 2개 이상이면 받아둔 함수를 즉시 실행하고 적다면 return한 이후에 인자를 합쳐서 실행
 91 |   const mult = curry((a, b) => a * b);
 92 | 
 93 |   log(mult(2)) // (..._) => f(a, ..._) => 나머지 인자를 더 전달했을 때, 함수에게 받어두둔 인자와 함께 실행
 94 |   log(mult(1)(2)) // 2
 95 | 
 96 |   const mult3 = mult(3); // 첫 인자가 3으로 고정된 mult 함수
 97 |   log(mult3(10)); // 30
 98 |   log(mult3(5)); // 15
 99 |   log(mult3(3)); // 9
100 |   console.clear();
101 | </script>
102 | 
103 | # 함수 조합으로 함수 만들기
104 | 
105 | <script>
106 |   go(
107 |       products,
108 |       products => filter(p => p.price < 20000, products), // 20000 미만인 상품들
109 |       products => map(p => p.price, products), // 20000 미만인 상품들의 가격
110 |       prices => reduce(add, prices), // 20000 미만인 상품들의 가격 총합
111 |       log);
112 | 
113 |   const total_price = pipe(
114 |     map(p => p.price),
115 |     reduce(add));
116 | 
117 |   // map, reduce를 total_price로 합침
118 |   go(
119 |     products,
120 |     products => filter(p => p.price < 20000, products), // 20000 미만인 상품들
121 |     total_price,
122 |     log);
123 | 
124 | 
125 |   const base_total_price = predi => pipe(
126 |     filter(predi),
127 |     total_price);
128 | 
129 |   // filter, total_price를 base_total_price로 합침
130 |   go(
131 |     products,
132 |     base_total_price(p => p.price < 20000),
133 |     log);
134 | 
135 |   go(
136 |     products,
137 |     base_total_price(p => p.price >= 20000),
138 |     log);
139 | </script>
140 | 


--------------------------------------------------------------------------------
/05. 코드를 값으로 다루어 표현력 높이기/1/lib/fx.js:
--------------------------------------------------------------------------------
 1 | const log = console.log;
 2 | /**
 3 |  * 함수를 받아서 함수를 return
 4 |  * 인자가 2개 이상이면 받아둔 함수를 즉시 실행하고 적다면 return한 이후에 인자를 합쳐서 실행
 5 |  *
 6 |  * 1. curry는 f라는 함수를 인자로 받아 새로운 함수를 반환하는 화살표 함수
 7 |  * 2. 첫번째 반환 함수: (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
 8 |  * 3. 인자 검사 및 호춣
 9 |  *  3-1. _.length가 참이면 f(a, ..._)를 호출해 즉시 결과를 반환
10 |  *  3-2. 거짓이면 다시 curry(f)를 호출해 나머지 인자를 받아 f(a, ..._)를 호출
11 |  */
12 | 
13 | const curry = f =>
14 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
15 | 
16 | const map = curry((f, iter) => {
17 |   let res = [];
18 |   for (const a of iter) {
19 |     res.push(f(a));
20 |   }
21 |   return res;
22 | });
23 | 
24 | const filter = curry((f, iter) => {
25 |   let res = [];
26 |   for (const a of iter) {
27 |     if (f(a)) res.push(a);
28 |   }
29 |   return res;
30 | });
31 | 
32 | const reduce = curry((f, acc, iter) => {
33 |   if (!iter) {
34 |     iter = acc[Symbol.iterator]();
35 |     acc = iter.next().value;
36 |   }
37 |   for (const a of iter) {
38 |     acc = f(acc, a);
39 |   }
40 |   return acc;
41 | });
42 | 


--------------------------------------------------------------------------------
/06. HTML 출력해보기/1/html/1.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <title>HTML 출력해보기 - 장바구니</title>
 6 |   <script src="../lib/fx.js"></script>
 7 | </head>
 8 | <body>
 9 | 
10 | <div id="cart">
11 | </div>
12 | 
13 | <script>
14 |   const products = [
15 |     {name: '반팔티', price: 15000, quantity: 1, is_selected: true},
16 |     {name: '긴팔티', price: 20000, quantity: 2, is_selected: false},
17 |     {name: '핸드폰케이스', price: 15000, quantity: 3, is_selected: true},
18 |     {name: '후드티', price: 30000, quantity: 4, is_selected: false},
19 |     {name: '바지', price: 25000, quantity: 5, is_selected: false}
20 |   ];
21 | 
22 |   const add = (a, b) => a + b;
23 | 
24 |   const sum = curry((f, iter) => go(
25 |     iter,
26 |     map(f),
27 |     reduce(add)));
28 | 
29 |   const total_quantity = sum(p => p.quantity);
30 | 
31 |   const total_price = sum(p => p.price * p.quantity);
32 | 
33 |   document.querySelector('#cart').innerHTML = `
34 |     <table>
35 |       <tr>
36 |         <th></th>
37 |         <th>상품 이름</th>
38 |         <th>가격</th>
39 |         <th>수량</th>
40 |         <th>총 가격</th>
41 |       </tr>
42 |       ${go(products, sum(p => `
43 |           <tr>
44 |             <td><input type="checkbox" ${p.is_selected ? 'checked' : ''}></td>
45 |             <td>${p.name}</td>
46 |             <td>${p.price}</td>
47 |             <td><input type="number" value="${p.quantity}"></td>
48 |             <td>${p.price * p.quantity}</td>
49 |           </tr>
50 |       `))}
51 |       <tr>
52 |         <td colspan="3">합계</td>
53 |         <td>${total_quantity(filter(p => p.is_selected, products))}</td>
54 |         <td>${total_price(filter(p => p.is_selected, products))}</td>
55 |       </tr>
56 |     </table>
57 |   `;
58 | </script>
59 | 
60 | </body>
61 | </html>


--------------------------------------------------------------------------------
/06. HTML 출력해보기/1/lib/fx.js:
--------------------------------------------------------------------------------
 1 | const log = console.log;
 2 | 
 3 | const curry = f =>
 4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
 5 | 
 6 | const map = curry((f, iter) => {
 7 |   let res = [];
 8 |   for (const a of iter) {
 9 |     res.push(f(a));
10 |   }
11 |   return res;
12 | });
13 | 
14 | const filter = curry((f, iter) => {
15 |   let res = [];
16 |   for (const a of iter) {
17 |     if (f(a)) res.push(a);
18 |   }
19 |   return res;
20 | });
21 | 
22 | const reduce = curry((f, acc, iter) => {
23 |   if (!iter) {
24 |     iter = acc[Symbol.iterator]();
25 |     acc = iter.next().value;
26 |   }
27 |   for (const a of iter) {
28 |     acc = f(acc, a);
29 |   }
30 |   return acc;
31 | });
32 | 
33 | const go = (...args) => reduce((a, f) => f(a), args);
34 | 
35 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
36 | 


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/1/html/1.html:
--------------------------------------------------------------------------------
 1 | <script src="../lib/fx.js"></script>
 2 | 
 3 | ## range
 4 | 
 5 | <script>
 6 |   var add = (a, b) => a + b;
 7 | 
 8 |   const range = l => {
 9 |     let i = -1;
10 |     let res = [];
11 |     while (++i < l) {
12 |       res.push(i);
13 |     }
14 |     return res;
15 |   };
16 | 
17 |   var list = range(4);
18 |   log(list);
19 |   log(reduce(add, list));
20 | </script>
21 | 
22 | ## 느긋한 L.range
23 | 
24 | <script>
25 |   const L = {};
26 |   L.range = function* (l) {
27 |     let i = -1;
28 |     while (++i < l) {
29 |       yield i;
30 |     }
31 |   };
32 | 
33 |   var list = L.range(4);
34 |   log(list);
35 |   log(reduce(add, list));
36 | </script>
37 | 
38 | <script>
39 |   function test(name, time, f) {
40 |     console.time(name);
41 |     while (time--) f();
42 |     console.timeEnd(name);
43 |   }
44 | 
45 |   // test('range', 10, () => reduce(add, range(1000000)));
46 |   // test('L.range', 10, () => reduce(add, L.range(1000000)));
47 |   console.clear();
48 | </script>
49 | 
50 | ## take
51 | 
52 | <script>
53 |   const take = curry((l, iter) => {
54 |     let res = [];
55 |     for (const a of iter) {
56 |       res.push(a);
57 |       if (res.length == l) return res;
58 |     }
59 |     return res;
60 |   });
61 |   console.time('');
62 |   go(
63 |     range(10000),
64 |     take(5),
65 |     reduce(add),
66 |     log);
67 |   console.timeEnd('');
68 | 
69 |   console.time('');
70 |   go(
71 |     L.range(10000),
72 |     take(5),
73 |     reduce(add),
74 |     log);
75 |   console.timeEnd('');
76 | </script>
77 | 
78 | 


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/1/lib/fx.js:
--------------------------------------------------------------------------------
 1 | const log = console.log;
 2 | 
 3 | const curry = f =>
 4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
 5 | 
 6 | const map = curry((f, iter) => {
 7 |   let res = [];
 8 |   for (const a of iter) {
 9 |     res.push(f(a));
10 |   }
11 |   return res;
12 | });
13 | 
14 | const filter = curry((f, iter) => {
15 |   let res = [];
16 |   for (const a of iter) {
17 |     if (f(a)) res.push(a);
18 |   }
19 |   return res;
20 | });
21 | 
22 | const reduce = curry((f, acc, iter) => {
23 |   if (!iter) {
24 |     iter = acc[Symbol.iterator]();
25 |     acc = iter.next().value;
26 |   }
27 |   for (const a of iter) {
28 |     acc = f(acc, a);
29 |   }
30 |   return acc;
31 | });
32 | 
33 | const go = (...args) => reduce((a, f) => f(a), args);
34 | 
35 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/2/html/2.html:
--------------------------------------------------------------------------------
  1 | <script src="../lib/fx.js"></script>
  2 | 
  3 | # 이터러블 중심 프로그래밍에서의 지연 평가 (Lazy Evaluation)
  4 | - 제때 계산법
  5 | - 느긋한 계산법
  6 | - 제너레이터/이터레이터 프로토콜을 기반으로 구현
  7 | 
  8 | ### L.map
  9 | 
 10 | <script>
 11 |   // L.map = function *(f, iter) {
 12 |   //   for (const a of iter) yield f(a);
 13 |   // };
 14 |   // var it = L.map(a => a + 10, [1, 2, 3]);
 15 |   // log(it.next());
 16 |   // log(it.next());
 17 |   // log(it.next());
 18 | </script>
 19 | 
 20 | ### L.filter
 21 | 
 22 | <script>
 23 |   // L.filter = function *(f, iter) {
 24 |   //   for (const a of iter) if (f(a)) yield a;
 25 |   // };
 26 |   // var it = L.filter(a => a % 2, [1, 2, 3, 4]);
 27 |   // log(it.next());
 28 |   // log(it.next());
 29 |   // log(it.next());
 30 | </script>
 31 | 
 32 | 
 33 | ### range, map, filter, take, reduce 중첩 사용
 34 | 
 35 | <script>
 36 |   const range = l => {
 37 |     let i = -1;
 38 |     let res = [];
 39 |     while (++i < l) {
 40 |       res.push(i);
 41 |     }
 42 |     return res;
 43 |   };
 44 | 
 45 |   const map = curry((f, iter) => {
 46 |     let res = [];
 47 |     iter = iter[Symbol.iterator]();
 48 |     let cur;
 49 |     while (!(cur = iter.next()).done) {
 50 |       const a = cur.value;
 51 |       res.push(f(a));
 52 |     }
 53 |     return res;
 54 |   });
 55 | 
 56 |   const filter = curry((f, iter) => {
 57 |     let res = [];
 58 |     iter = iter[Symbol.iterator]();
 59 |     let cur;
 60 |     while (!(cur = iter.next()).done) {
 61 |       const a = cur.value;
 62 |       if (f(a)) res.push(a);
 63 |     }
 64 |     return res;
 65 |   });
 66 | 
 67 |   const take = curry((l, iter) => {
 68 |     let res = [];
 69 |     iter = iter[Symbol.iterator]();
 70 |     let cur;
 71 |     while (!(cur = iter.next()).done) {
 72 |       const a = cur.value;
 73 |       res.push(a);
 74 |       if (res.length == l) return res;
 75 |     }
 76 |     return res;
 77 |   });
 78 | 
 79 |   const reduce = curry((f, acc, iter) => {
 80 |     if (!iter) {
 81 |       iter = acc[Symbol.iterator]();
 82 |       acc = iter.next().value;
 83 |     } else {
 84 |       iter = iter[Symbol.iterator]();
 85 |     }
 86 |     let cur;
 87 |     while (!(cur = iter.next()).done) {
 88 |       const a = cur.value;
 89 |       acc = f(acc, a);
 90 |     }
 91 |     return acc;
 92 |   });
 93 | 
 94 |   // console.time('');
 95 |   // go(range(100000),
 96 |   //   map(n => n + 10),
 97 |   //   filter(n => n % 2),
 98 |   //   take(10),
 99 |   //   log);
100 |   // console.timeEnd('');
101 | </script>
102 | 
103 | ### L.range, L.map, L.filter, take, reduce 중첩 사용
104 | 
105 | <script>
106 |   L.range = function* (l) {
107 |     let i = -1;
108 |     while (++i < l) {
109 |       yield i;
110 |     }
111 |   };
112 | 
113 |   L.map = curry(function* (f, iter) {
114 |     iter = iter[Symbol.iterator]();
115 |     let cur;
116 |     while (!(cur = iter.next()).done) {
117 |       const a = cur.value;
118 |       yield f(a);
119 |     }
120 |   });
121 | 
122 |   L.filter = curry(function* (f, iter) {
123 |     iter = iter[Symbol.iterator]();
124 |     let cur;
125 |     while (!(cur = iter.next()).done) {
126 |       const a = cur.value;
127 |       if (f(a)) {
128 |         yield a;
129 |       }
130 |     }
131 |   });
132 | 
133 |   // [0, 1, 2, 3, 4, 5, 6, 7, 8...]
134 |   // [10, 11, 12, ...]
135 |   // [11, 13, 15 ..]
136 |   // [11, 13]
137 |   //
138 |   // [0    [1
139 |   // 10     11
140 |   // false]  true]
141 |   //
142 | 
143 |   // console.time('L');
144 |   // go(L.range(Infinity),
145 |   //   L.map(n => n + 10),
146 |   //   L.filter(n => n % 2),
147 |   //   take(10),
148 |   //   log);
149 |   // console.timeEnd('L');
150 | </script>
151 | 
152 | ### map, filter 계열 함수들이 가지는 결합 법칙
153 | 
154 | - 사용하는 데이터가 무엇이든지
155 | - 사용하는 보조 함수가 순수 함수라면 무엇이든지
156 | - 아래와 같이 결합한다면 둘 다 결과가 같다.
157 | 
158 | [[mapping, mapping], [filtering, filtering], [mapping, mapping]]
159 | =
160 | [[mapping, filtering, mapping], [mapping, filtering, mapping]]
161 | 
162 | 
163 | ## 결과를 만드는 함수 reduce, take
164 | 
165 | ### reduce
166 | 
167 | <script>
168 |   L.entries = function* (obj) {
169 |     for (const k in obj) yield [k, obj[k]];
170 |   };
171 | 
172 |   const join = curry((sep = ',', iter) =>
173 |     reduce((a, b) => `${a}${sep}${b}`, iter));
174 | 
175 |   const queryStr = pipe(
176 |     L.entries,
177 |     L.map(([k, v]) => `${k}=${v}`),
178 |     join('&'));
179 | 
180 |   log(queryStr({limit: 10, offset: 10, type: 'notice'}));
181 | 
182 |   // function *a() {
183 |   //   yield 10;
184 |   //   yield 11;
185 |   //   yield 12;
186 |   //   yield 13;
187 |   // }
188 |   //
189 |   // log(join(' - ', a()));
190 | </script>
191 | 
192 | ### take, find
193 | 
194 | <script>
195 |   const users = [
196 |     {age: 32},
197 |     {age: 31},
198 |     {age: 37},
199 |     {age: 28},
200 |     {age: 25},
201 |     {age: 32},
202 |     {age: 31},
203 |     {age: 37}
204 |   ];
205 | 
206 |   const find = curry((f, iter) => go(
207 |     iter,
208 |     L.filter(f),
209 |     take(1),
210 |     ([a]) => a));
211 | 
212 |   log(find(u => u.age < 30)(users));
213 | 
214 |   go(users,
215 |     L.map(u => u.age),
216 |     find(n => n < 30),
217 |     log);
218 | </script>


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/2/lib/fx.js:
--------------------------------------------------------------------------------
 1 | const log = console.log;
 2 | 
 3 | const curry = f =>
 4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
 5 | 
 6 | // const map = curry((f, iter) => {
 7 | //   let res = [];
 8 | //   for (const a of iter) {
 9 | //     res.push(f(a));
10 | //   }
11 | //   return res;
12 | // });
13 | //
14 | // const filter = curry((f, iter) => {
15 | //   let res = [];
16 | //   for (const a of iter) {
17 | //     if (f(a)) res.push(a);
18 | //   }
19 | //   return res;
20 | // });
21 | 
22 | // const reduce = curry((f, acc, iter) => {
23 | //   if (!iter) {
24 | //     iter = acc[Symbol.iterator]();
25 | //     acc = iter.next().value;
26 | //   }
27 | //   for (const a of iter) {
28 | //     acc = f(acc, a);
29 | //   }
30 | //   return acc;
31 | // });
32 | 
33 | const go = (...args) => reduce((a, f) => f(a), args);
34 | 
35 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
36 | 
37 | var add = (a, b) => a + b;
38 | 
39 | // const range = l => {
40 | //   let i = -1;
41 | //   let res = [];
42 | //   while (++i < l) {
43 | //     res.push(i);
44 | //   }
45 | //   return res;
46 | // };
47 | 
48 | const L = {};
49 | 


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/3/html/1.html:
--------------------------------------------------------------------------------
 1 | <script src="../lib/fx.js"></script>
 2 | <script>
 3 |   // ## L.map + take로 map 만들기
 4 | 
 5 |   L.map = curry(function* (f, iter) {
 6 |     for (const a of iter) {
 7 |       yield f(a);
 8 |     }
 9 |   });
10 | 
11 |   const takeAll = take(Infinity);
12 | 
13 |   const map = curry(pipe(L.map, takeAll));
14 | 
15 |   log(map(a => a + 10, L.range(4)));
16 | 
17 |   // ## L.filter + take로 filter 만들기
18 | 
19 |   L.filter = curry(function* (f, iter) {
20 |     for (const a of iter) {
21 |       if (f(a)) yield a;
22 |     }
23 |   });
24 | 
25 |   const filter = curry(pipe(L.filter, takeAll));
26 | 
27 |   log(filter(a => a % 2, range(4)));
28 | </script>


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/3/lib/fx.js:
--------------------------------------------------------------------------------
 1 | const log = console.log;
 2 | 
 3 | const curry = f =>
 4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
 5 | 
 6 | const L = {};
 7 | 
 8 | L.range = function* (l) {
 9 |   let i = -1;
10 |   while (++i < l) {
11 |     yield i;
12 |   }
13 | };
14 | 
15 | L.entries = function* (obj) {
16 |   for (const k in obj) yield [k, obj[k]];
17 | };
18 | 
19 | const take = curry((l, iter) => {
20 |   let res = [];
21 |   iter = iter[Symbol.iterator]();
22 |   let cur;
23 |   while (!(cur = iter.next()).done) {
24 |     const a = cur.value;
25 |     res.push(a);
26 |     if (res.length == l) return res;
27 |   }
28 |   return res;
29 | });
30 | 
31 | const reduce = curry((f, acc, iter) => {
32 |   if (!iter) {
33 |     iter = acc[Symbol.iterator]();
34 |     acc = iter.next().value;
35 |   } else {
36 |     iter = iter[Symbol.iterator]();
37 |   }
38 |   let cur;
39 |   while (!(cur = iter.next()).done) {
40 |     const a = cur.value;
41 |     acc = f(acc, a);
42 |   }
43 |   return acc;
44 | });
45 | 
46 | const find = curry((f, iter) => go(
47 |   iter,
48 |   L.filter(f),
49 |   take(1),
50 |   ([a]) => a));
51 | 
52 | const go = (...args) => reduce((a, f) => f(a), args);
53 | 
54 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
55 | 
56 | var add = (a, b) => a + b;
57 | 
58 | const range = l => {
59 |   let i = -1;
60 |   let res = [];
61 |   while (++i < l) {
62 |     res.push(i);
63 |   }
64 |   return res;
65 | };


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/4/html/1.html:
--------------------------------------------------------------------------------
  1 | <script src="../lib/fx.js"></script>
  2 | 
  3 | ## L.flatten
  4 | 
  5 | <script>
  6 |   log([...[1, 2], 3, 4, ...[5, 6], ...[7, 8, 9]]);
  7 | 
  8 |   const isIterable = a => a && a[Symbol.iterator];
  9 | 
 10 |   L.flatten = function* (iter) {
 11 |     for (const a of iter) {
 12 |       if (isIterable(a)) for (const b of a) yield b
 13 |       else yield a;
 14 |     }
 15 |   };
 16 | 
 17 |   var it = L.flatten([[1, 2], 3, 4, [5, 6], [7, 8, 9]]);
 18 |   log(it.next());
 19 |   log(it.next());
 20 |   log(it.next());
 21 |   log(it.next());
 22 |   log(take(6, L.flatten([[1, 2], 3, 4, [5, 6], [7, 8, 9]])));
 23 | 
 24 |   // log(it.next());
 25 |   // log(it.next());
 26 |   // log(it.next());
 27 |   // log(it.next());
 28 |   const flatten = pipe(L.flatten, takeAll);
 29 |   log(flatten([[1, 2], 3, 4, [5, 6], [7, 8, 9]]));
 30 | 
 31 |   console.clear();
 32 | </script>
 33 | 
 34 | ## yield *
 35 | 
 36 | <script>
 37 |   L.flatten = function* (iter) {
 38 |     for (const a of iter) {
 39 |       if (isIterable(a)) for (const b of a) yield b
 40 |       else yield a;
 41 |     }
 42 |   };
 43 | </script>
 44 | 
 45 | `yield *`을 활용하면 위 코드를 아래와 같이 변경할 수 있습니다. `yield *iterable`은 `for (const val of iterable) yield val;` 과 같습니다.
 46 | 
 47 | <script>
 48 |   L.flatten = function* (iter) {
 49 |     for (const a of iter) {
 50 |       if (isIterable(a)) yield* a;
 51 |       else yield a;
 52 |     }
 53 |   };
 54 | </script>
 55 | 
 56 | ## L.deepFlat
 57 | 
 58 | 만일 깊은 Iterable을 모두 펼치고 싶다면 아래와 같이 `L.deepFlat`을 구현하여 사용할 수 있습니다. `L.deepFlat`은 깊은 Iterable을 펼쳐줍니다.
 59 | 
 60 | <script>
 61 |   L.deepFlat = function* f(iter) {
 62 |     for (const a of iter) {
 63 |       if (isIterable(a)) yield* f(a);
 64 |       else yield a;
 65 |     }
 66 |   };
 67 |   log([...L.deepFlat([1, [2, [3, 4], [[5]]]])]);
 68 |   // [1, 2, 3, 4, 5];
 69 | </script>
 70 | 
 71 | ## L.flatMap
 72 | 
 73 | <script>
 74 |   // log([[1, 2], [3, 4], [5, 6, 7]].flatMap(a => a));
 75 |   // log([[1, 2], [3, 4], [5, 6, 7]].flatMap(a => a.map(a => a * a)));
 76 |   // log(flatten([[1, 2], [3, 4], [5, 6, 7]].map(a => a.map(a => a * a))));
 77 |   // log(flatten([[1, 2], [3, 4], [5, 6, 7]].map(a => a.map(a => a * a))));
 78 | 
 79 |   L.flatMap = curry(pipe(L.map, L.flatten));
 80 |   const flatMap = curry(pipe(L.map, flatten));
 81 | 
 82 |   // var it = L.flatMap(map(a => a * a), [[1, 2], [3, 4], [5, 6, 7]]);
 83 |   var it = L.flatMap(a => a, [[1, 2], [3, 4], [5, 6, 7]]);
 84 |   log([...it]);
 85 |   // log(it.next());
 86 |   // log(it.next());
 87 |   // log(it.next());
 88 |   // log(it.next());
 89 |   // log(it.next());
 90 |   // log(it.next());
 91 |   // log(it.next());
 92 |   log(flatMap(a => a, [[1, 2], [3, 4], [5, 6, 7]]));
 93 | 
 94 |   log(flatMap(L.range, map(a => a + 1, [1, 2, 3])));
 95 | 
 96 |   var it = L.flatMap(L.range, map(a => a + 1, [1, 2, 3]));
 97 |   log(it.next());
 98 |   log(it.next());
 99 |   log(it.next());
100 |   log(it.next());
101 | 
102 |   log(take(3, L.flatMap(L.range, map(a => a + 1, [1, 2, 3]))));
103 |   console.clear();
104 | </script>
105 | 
106 | 
107 | ## 2차원 배열 다루기
108 | 
109 | <script>
110 |   const arr = [
111 |     [1, 2],
112 |     [3, 4, 5],
113 |     [6, 7, 8],
114 |     [9, 10]
115 |   ];
116 | 
117 |   go(arr,
118 |     L.flatten,
119 |     L.filter(a => a % 2),
120 |     L.map(a => a * a),
121 |     take(4),
122 |     reduce(add),
123 |     log);
124 | </script>
125 | 
126 | 
127 | ## 지연성 / 이터러블 중심 프로그래밍 실무적인 코드
128 | 
129 | <script>
130 |   var users = [
131 |     {
132 |       name: 'a', age: 21, family: [
133 |         {name: 'a1', age: 53}, {name: 'a2', age: 47},
134 |         {name: 'a3', age: 16}, {name: 'a4', age: 15}
135 |       ]
136 |     },
137 |     {
138 |       name: 'b', age: 24, family: [
139 |         {name: 'b1', age: 58}, {name: 'b2', age: 51},
140 |         {name: 'b3', age: 19}, {name: 'b4', age: 22}
141 |       ]
142 |     },
143 |     {
144 |       name: 'c', age: 31, family: [
145 |         {name: 'c1', age: 64}, {name: 'c2', age: 62}
146 |       ]
147 |     },
148 |     {
149 |       name: 'd', age: 20, family: [
150 |         {name: 'd1', age: 42}, {name: 'd2', age: 42},
151 |         {name: 'd3', age: 11}, {name: 'd4', age: 7}
152 |       ]
153 |     }
154 |   ];
155 | 
156 |   go(users,
157 |     L.flatMap(u => u.family),
158 |     L.filter(u => u.age > 20),
159 |     L.map(u => u.age),
160 |     take(4),
161 |     reduce(add),
162 |     log);
163 | </script>
164 | 
165 | 


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/4/html/yield...md:
--------------------------------------------------------------------------------
 1 | ## yield*
 2 | 
 3 | ```javascript
 4 | L.flatten = function* (iter) {
 5 |   for (const a of iter) {
 6 |     if (isIterable(a)) for (const b of a) yield b
 7 |     else yield a;
 8 |   }
 9 | };
10 | ```
11 | 
12 | `yield*`을 활용하면 위 코드를 아래와 같이 변경할 수 있습니다. `yield* iterable`은 `for (const val of iterable) yield val;` 과 같습니다.
13 | 
14 | ```javascript
15 | L.flatten = function* (iter) {
16 |   for (const a of iter) {
17 |     if (isIterable(a)) yield* a;
18 |     else yield a;
19 |   }
20 | };
21 | ```
22 | 
23 | ## L.deepFlat
24 | 
25 | 만일 깊은 Iterable을 모두 펼치고 싶다면 아래와 같이 `L.deepFlat`을 구현하여 사용할 수 있습니다. `L.deepFlat`은 깊은 Iterable을 펼쳐줍니다.
26 | 
27 | ```javascript
28 | L.deepFlat = function* f(iter) {
29 |   for (const a of iter) {
30 |     if (isIterable(a)) yield* f(a);
31 |     else yield a;
32 |   }
33 | };
34 | log([...L.deepFlat([1, [2, [3, 4], [[5]]]])]);
35 | // [1, 2, 3, 4, 5];
36 | ```


--------------------------------------------------------------------------------
/07. 지연성 1, 8. 지연성 2/4/lib/fx.js:
--------------------------------------------------------------------------------
 1 | const log = console.log;
 2 | 
 3 | const curry = f =>
 4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
 5 | 
 6 | const reduce = curry((f, acc, iter) => {
 7 |   if (!iter) {
 8 |     iter = acc[Symbol.iterator]();
 9 |     acc = iter.next().value;
10 |   } else {
11 |     iter = iter[Symbol.iterator]();
12 |   }
13 |   let cur;
14 |   while (!(cur = iter.next()).done) {
15 |     const a = cur.value;
16 |     acc = f(acc, a);
17 |   }
18 |   return acc;
19 | });
20 | 
21 | const go = (...args) => reduce((a, f) => f(a), args);
22 | 
23 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
24 | 
25 | const take = curry((l, iter) => {
26 |   let res = [];
27 |   iter = iter[Symbol.iterator]();
28 |   let cur;
29 |   while (!(cur = iter.next()).done) {
30 |     const a = cur.value;
31 |     res.push(a);
32 |     if (res.length == l) return res;
33 |   }
34 |   return res;
35 | });
36 | 
37 | const takeAll = take(Infinity);
38 | 
39 | const L = {};
40 | 
41 | L.range = function* (l) {
42 |   let i = -1;
43 |   while (++i < l) yield i;
44 | };
45 | 
46 | L.map = curry(function* (f, iter) {
47 |   for (const a of iter) {
48 |     yield f(a);
49 |   }
50 | });
51 | 
52 | L.filter = curry(function* (f, iter) {
53 |   for (const a of iter) {
54 |     if (f(a)) yield a;
55 |   }
56 | });
57 | 
58 | L.entries = function* (obj) {
59 |   for (const k in obj) yield [k, obj[k]];
60 | };
61 | 
62 | const map = curry(pipe(L.map, takeAll));
63 | 
64 | const filter = curry(pipe(L.filter, takeAll));
65 | 
66 | const find = curry((f, iter) => go(
67 |   iter,
68 |   L.filter(f),
69 |   take(1),
70 |   ([a]) => a));
71 | 
72 | var add = (a, b) => a + b;
73 | 
74 | const range = l => {
75 |   let i = -1;
76 |   let res = [];
77 |   while (++i < l) {
78 |     res.push(i);
79 |   }
80 |   return res;
81 | };


--------------------------------------------------------------------------------
/09. 비동기 동시성 프로그래밍/1/html/1-1.html:
--------------------------------------------------------------------------------
  1 | <script src="../lib/fx.js"></script>
  2 | 
  3 | # Promise
  4 | 
  5 | ## 일급
  6 | 
  7 | <script>
  8 |   function add10(a, callback) {
  9 |     setTimeout(() => callback(a + 10), 100);
 10 |   }
 11 | 
 12 |   var a = add10(5, res => {
 13 |     add10(res, res => {
 14 |       add10(res, res => {
 15 |         // log(res);
 16 |       });
 17 |     });
 18 |   });
 19 | 
 20 |   // log(a);
 21 | 
 22 |   function add20(a) {
 23 |     return new Promise(resolve => setTimeout(() => resolve(a + 20), 100));
 24 |   }
 25 | 
 26 |   var b = add20(5)
 27 |     .then(add20)
 28 |     .then(add20)
 29 |   // .then(log);
 30 | 
 31 |   // log(b);
 32 | </script>
 33 | 
 34 | ## 일급 활용
 35 | 
 36 | <script>
 37 |   const delay100 = a => new Promise(resolve =>
 38 |     setTimeout(() => resolve(a), 100));
 39 | 
 40 |   const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);
 41 |   const add5 = a => a + 5;
 42 | 
 43 |   const n1 = 10;
 44 |   // log(go1(go1(n1, add5), log));
 45 | 
 46 |   const n2 = delay100(10);
 47 |   // log(go1(go1(n2, add5), log));
 48 | </script>
 49 | 
 50 | ## Composition
 51 | 
 52 | <script type="module">
 53 |   // f . g
 54 |   // f(g(x))
 55 | 
 56 |   const g = a => a + 1;
 57 |   const f = a => a * a;
 58 | 
 59 |   // log(f(g(1)));
 60 |   // log(f(g()));
 61 | 
 62 |   Array.of(1).map(g).map(f)/*.forEach(r => log(r))*/;
 63 |   [].map(g).map(f)/*.forEach(r => log(r))*/;
 64 | 
 65 |   Promise.resolve(2).then(g).then(f)/*.then(r => log(r))*/;
 66 |   new Promise(resolve =>
 67 |     setTimeout(() => resolve(2), 100)
 68 |   ).then(g).then(f)/*.then(r => log(r))*/;
 69 | </script>
 70 | 
 71 | ## Kleisli Composition
 72 | 
 73 | <script>
 74 |   // f . g
 75 |   // f(g(x)) = f(g(x))
 76 |   // f(g(x)) = g(x)
 77 | 
 78 |   var users = [
 79 |     {id: 1, name: 'aa'},
 80 |     {id: 2, name: 'bb'},
 81 |     {id: 3, name: 'cc'}
 82 |   ];
 83 | 
 84 |   const getUserById = id =>
 85 |     find(u => u.id == id, users) || Promise.reject('없어요!');
 86 | 
 87 |   const f = ({name}) => name;
 88 |   const g = getUserById;
 89 | 
 90 |   // const fg = id => f(g(id));
 91 | 
 92 |   const fg = id => Promise.resolve(id).then(g).then(f).catch(a => a);
 93 | 
 94 |   fg(2).then(log);
 95 | 
 96 |   setTimeout(function () {
 97 |     users.pop();
 98 |     users.pop();
 99 |     fg(2).then(log);
100 |   }, 10);
101 | </script>
102 | 
103 | 
104 | 


--------------------------------------------------------------------------------
/09. 비동기 동시성 프로그래밍/1/html/1-2.html:
--------------------------------------------------------------------------------
 1 | <script src="../lib/fx.js"></script>
 2 | 
 3 | ## go, pipe, reduce에서 비동기 제어
 4 | 
 5 | <script>
 6 |   go(Promise.resolve(1),
 7 |     a => a + 10,
 8 |     a => Promise.reject('error~~'),
 9 |     a => console.log('----'),
10 |     a => a + 1000,
11 |     a => a + 10000,
12 |     log).catch(a => console.log(a));
13 | </script>


--------------------------------------------------------------------------------
/09. 비동기 동시성 프로그래밍/1/html/1-3.html:
--------------------------------------------------------------------------------
 1 | <script src="../lib/fx.js"></script>
 2 | 
 3 | ## promise.then의 중요한 규칙
 4 | 
 5 | <script>
 6 |   Promise.resolve(Promise.resolve(1)).then(function (a) {
 7 |     log(a);
 8 |   });
 9 | 
10 |   new Promise(resolve => resolve(new Promise(resolve => resolve(1)))).then(log);
11 | </script>


--------------------------------------------------------------------------------
/09. 비동기 동시성 프로그래밍/1/lib/fx.js:
--------------------------------------------------------------------------------
  1 | const log = console.log;
  2 | 
  3 | const curry = f =>
  4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
  5 | 
  6 | const isIterable = a => a && a[Symbol.iterator];
  7 | 
  8 | const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);
  9 | 
 10 | const reduce = curry((f, acc, iter) => {
 11 |   if (!iter) {
 12 |     iter = acc[Symbol.iterator]();
 13 |     acc = iter.next().value;
 14 |   } else {
 15 |     iter = iter[Symbol.iterator]();
 16 |   }
 17 |   return go1(acc, function recur(acc) {
 18 |     let cur;
 19 |     while (!(cur = iter.next()).done) {
 20 |       const a = cur.value;
 21 |       acc = f(acc, a);
 22 |       if (acc instanceof Promise) return acc.then(recur);
 23 |     }
 24 |     return acc;
 25 |   });
 26 | });
 27 | 
 28 | const go = (...args) => reduce((a, f) => f(a), args);
 29 | 
 30 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
 31 | 
 32 | const take = curry((l, iter) => {
 33 |   let res = [];
 34 |   iter = iter[Symbol.iterator]();
 35 |   let cur;
 36 |   while (!(cur = iter.next()).done) {
 37 |     const a = cur.value;
 38 |     res.push(a);
 39 |     if (res.length == l) return res;
 40 |   }
 41 |   return res;
 42 | });
 43 | 
 44 | const takeAll = take(Infinity);
 45 | 
 46 | const L = {};
 47 | 
 48 | L.range = function* (l) {
 49 |   let i = -1;
 50 |   while (++i < l) yield i;
 51 | };
 52 | 
 53 | L.map = curry(function* (f, iter) {
 54 |   for (const a of iter) {
 55 |     yield f(a);
 56 |   }
 57 | });
 58 | 
 59 | L.filter = curry(function* (f, iter) {
 60 |   for (const a of iter) {
 61 |     if (f(a)) yield a;
 62 |   }
 63 | });
 64 | 
 65 | L.entries = function* (obj) {
 66 |   for (const k in obj) yield [k, obj[k]];
 67 | };
 68 | 
 69 | L.flatten = function* (iter) {
 70 |   for (const a of iter) {
 71 |     if (isIterable(a)) yield* a;
 72 |     else yield a;
 73 |   }
 74 | };
 75 | 
 76 | L.deepFlat = function* f(iter) {
 77 |   for (const a of iter) {
 78 |     if (isIterable(a)) yield* f(a);
 79 |     else yield a;
 80 |   }
 81 | };
 82 | 
 83 | L.flatMap = curry(pipe(L.map, L.flatten));
 84 | 
 85 | const map = curry(pipe(L.map, takeAll));
 86 | 
 87 | const filter = curry(pipe(L.filter, takeAll));
 88 | 
 89 | const find = curry((f, iter) => go(
 90 |   iter,
 91 |   L.filter(f),
 92 |   take(1),
 93 |   ([a]) => a));
 94 | 
 95 | const flatten = pipe(L.flatten, takeAll);
 96 | 
 97 | const flatMap = curry(pipe(L.map, flatten));
 98 | 
 99 | var add = (a, b) => a + b;
100 | 
101 | const range = l => {
102 |   let i = -1;
103 |   let res = [];
104 |   while (++i < l) {
105 |     res.push(i);
106 |   }
107 |   return res;
108 | };
109 | 


--------------------------------------------------------------------------------
/10. 비동기 동시성 프로그래밍 2/1/html/1-1.html:
--------------------------------------------------------------------------------
 1 | <script src="../lib/fx.js"></script>
 2 | 
 3 | ## 지연 평가 + Promise - L.map, map, take
 4 | 
 5 | <script>
 6 |   /*  go(
 7 |       [1, 2, 3],
 8 |       L.map(a => Promise.resolve(a + 10)),
 9 |       take(2),
10 |       log);
11 | 
12 |     go(
13 |       [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
14 |       L.map(a => a + 10),
15 |       take(2),
16 |       log);
17 | 
18 |     go(
19 |       [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
20 |       L.map(a => Promise.resolve(a + 10)),
21 |       take(2),
22 |       log);
23 | 
24 |     go(
25 |       [1, 2, 3],
26 |       map(a => Promise.resolve(a + 10)),
27 |       log);
28 | 
29 |     go(
30 |       [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
31 |       map(a => a + 10),
32 |       log);
33 | 
34 |     go(
35 |       [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
36 |       map(a => Promise.resolve(a + 10)),
37 |       log);*/
38 | </script>
39 | 
40 | ## Kleisli Composition - L.filter, filter, nop, take
41 | 
42 | <script>
43 |   go([1, 2, 3, 4, 5, 6],
44 |     L.map(a => Promise.resolve(a * a)),
45 |     // L.map(a => a * a),
46 |     filter(a => Promise.resolve(a % 2)),
47 |     // L.map(a => a * a),
48 |     /*L.map(a => {
49 |       log(a);
50 |       return a * a;
51 |     }),
52 |     L.map(a => {
53 |       log(a);
54 |       return a * a;
55 |     }),*/
56 |     // take(4),
57 |     /*log*/);
58 | </script>
59 | 
60 | ## reduce에서 nop 지원
61 | 
62 | <script>
63 |   go([1, 2, 3, 4, 5],
64 |     L.map(a => Promise.resolve(a * a)),
65 |     L.filter(a => Promise.resolve(a % 2)),
66 |     reduce(add)/*,
67 |     log*/);
68 | </script>
69 | 
70 | <script>
71 |   go([1, 2, 3, 4, 5, 6, 7, 8],
72 |     L.map(a => {
73 |       log(a);
74 |       return new Promise(resolve => setTimeout(() => resolve(a * a), 1000))
75 |     }),
76 |     L.filter(a => {
77 |       log(a);
78 |       return new Promise(resolve => setTimeout(() => resolve(a % 2), 1000))
79 |     }),
80 |     take(2),
81 |     reduce(add),
82 |     log);
83 | </script>
84 | 
85 | 
86 | 
87 | 


--------------------------------------------------------------------------------
/10. 비동기 동시성 프로그래밍 2/1/html/1-2.html:
--------------------------------------------------------------------------------
 1 | <script src="../lib/fx.js"></script>
 2 | 
 3 | ## 지연된 함수열을 병렬적으로 평가하기 - C.reduce, C.take
 4 | 
 5 | <script>
 6 |   const C = {};
 7 | 
 8 |   function noop() {
 9 |   }
10 | 
11 |   const catchNoop = ([...arr]) =>
12 |     (arr.forEach(a => a instanceof Promise ? a.catch(noop) : a), arr);
13 | 
14 |   C.reduce = curry((f, acc, iter) => iter ?
15 |     reduce(f, acc, catchNoop(iter)) :
16 |     reduce(f, catchNoop(acc)));
17 | 
18 |   C.take = curry((l, iter) => take(l, catchNoop(iter)));
19 | 
20 |   C.takeAll = C.take(Infinity);
21 | 
22 |   C.map = curry(pipe(L.map, C.takeAll));
23 | 
24 |   C.filter = curry(pipe(L.filter, C.takeAll));
25 | 
26 |   const delay1000 = a => new Promise(resolve => {
27 |     console.log('hi~');
28 |     setTimeout(() => resolve(a), 1000);
29 |   });
30 |   /*  // console.time('');
31 |     go([1, 2, 3, 4, 5, 6, 7, 8, 9],
32 |       L.map(a => delay1000(a * a)),
33 |       L.filter(a => delay1000(a % 2)),
34 |       L.map(a => delay1000(a * a)),
35 |       // C.take(2),
36 |       C.reduce(add),
37 |       /!*log,
38 |       _ => console.timeEnd('')*!/);*/
39 | </script>
40 | 
41 | ## 즉시 병렬적으로 평가하기 - C.map, C.filter
42 | 
43 | <script>
44 |   // C.map(a => delay1000(a * a), [1, 2, 3, 4]).then(log);
45 |   // C.filter(a => delay1000(a % 2), [1, 2, 3, 4]).then(log);
46 | </script>
47 | 
48 | ## 즉시, 지연, Promise, 병렬적 조합하기
49 | 
50 | <script>
51 |   // const delay500 = a => a;
52 |   const delay500 = (a, name) => new Promise(resolve => {
53 |     console.log(`${name}: ${a}`);
54 |     setTimeout(() => resolve(a), 100);
55 |   });
56 | 
57 |   console.time('');
58 |   go([1, 2, 3, 4, 5, 6, 7, 8],
59 |     L.map(a => delay500(a * a, 'map 1')),
60 |     L.filter(a => delay500(a % 2, 'filter 2')),
61 |     L.map(a => delay500(a + 1, 'map 3')),
62 |     C.take(2),
63 |     reduce(add),
64 |     log,
65 |     _ => console.timeEnd(''));
66 | </script>


--------------------------------------------------------------------------------
/10. 비동기 동시성 프로그래밍 2/1/lib/fx.js:
--------------------------------------------------------------------------------
  1 | const log = console.log;
  2 | 
  3 | const curry = f =>
  4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
  5 | 
  6 | const isIterable = a => a && a[Symbol.iterator];
  7 | 
  8 | const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);
  9 | 
 10 | const reduceF = (acc, a, f) =>
 11 |   a instanceof Promise ?
 12 |     a.then(a => f(acc, a), e => e == nop ? acc : Promise.reject(e)) :
 13 |     f(acc, a);
 14 | 
 15 | const head = iter => go1(take(1, iter), ([h]) => h);
 16 | 
 17 | const reduce = curry((f, acc, iter) => {
 18 |   if (!iter) return reduce(f, head(iter = acc[Symbol.iterator]()), iter);
 19 | 
 20 |   iter = iter[Symbol.iterator]();
 21 |   return go1(acc, function recur(acc) {
 22 |     let cur;
 23 |     while (!(cur = iter.next()).done) {
 24 |       acc = reduceF(acc, cur.value, f);
 25 |       if (acc instanceof Promise) return acc.then(recur);
 26 |     }
 27 |     return acc;
 28 |   });
 29 | });
 30 | 
 31 | const go = (...args) => reduce((a, f) => f(a), args);
 32 | 
 33 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
 34 | 
 35 | const take = curry((l, iter) => {
 36 |   let res = [];
 37 |   iter = iter[Symbol.iterator]();
 38 |   return function recur() {
 39 |     let cur;
 40 |     while (!(cur = iter.next()).done) {
 41 |       const a = cur.value;
 42 |       if (a instanceof Promise) {
 43 |         return a
 44 |           .then(a => (res.push(a), res).length == l ? res : recur())
 45 |           .catch(e => e == nop ? recur() : Promise.reject(e));
 46 |       }
 47 |       res.push(a);
 48 |       if (res.length == l) return res;
 49 |     }
 50 |     return res;
 51 |   }();
 52 | });
 53 | 
 54 | const takeAll = take(Infinity);
 55 | 
 56 | const L = {};
 57 | 
 58 | L.range = function* (l) {
 59 |   let i = -1;
 60 |   while (++i < l) yield i;
 61 | };
 62 | 
 63 | L.map = curry(function* (f, iter) {
 64 |   for (const a of iter) {
 65 |     yield go1(a, f);
 66 |   }
 67 | });
 68 | 
 69 | const nop = Symbol('nop');
 70 | 
 71 | L.filter = curry(function* (f, iter) {
 72 |   for (const a of iter) {
 73 |     const b = go1(a, f);
 74 |     if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(nop));
 75 |     else if (b) yield a;
 76 |   }
 77 | });
 78 | 
 79 | L.entries = function* (obj) {
 80 |   for (const k in obj) yield [k, obj[k]];
 81 | };
 82 | 
 83 | L.flatten = function* (iter) {
 84 |   for (const a of iter) {
 85 |     if (isIterable(a)) yield* a;
 86 |     else yield a;
 87 |   }
 88 | };
 89 | 
 90 | L.deepFlat = function* f(iter) {
 91 |   for (const a of iter) {
 92 |     if (isIterable(a)) yield* f(a);
 93 |     else yield a;
 94 |   }
 95 | };
 96 | 
 97 | L.flatMap = curry(pipe(L.map, L.flatten));
 98 | 
 99 | const map = curry(pipe(L.map, takeAll));
100 | 
101 | const filter = curry(pipe(L.filter, takeAll));
102 | 
103 | const find = curry((f, iter) => go(
104 |   iter,
105 |   L.filter(f),
106 |   take(1),
107 |   ([a]) => a));
108 | 
109 | const flatten = pipe(L.flatten, takeAll);
110 | 
111 | const flatMap = curry(pipe(L.map, flatten));
112 | 
113 | var add = (a, b) => a + b;
114 | 
115 | const range = l => {
116 |   let i = -1;
117 |   let res = [];
118 |   while (++i < l) {
119 |     res.push(i);
120 |   }
121 |   return res;
122 | };
123 | 


--------------------------------------------------------------------------------
/11. 비동기 동시성 프로그래밍 3/1/html/1-1.html:
--------------------------------------------------------------------------------
  1 | <script src="../lib/fx.js"></script>
  2 | 
  3 | ## async/await
  4 | 
  5 | <script>
  6 |   function delay(time) {
  7 |     return new Promise(resolve => setTimeout(() => resolve(), time));
  8 |   }
  9 | 
 10 |   async function delayIdentity(a) {
 11 |     await delay(500);
 12 |     return a;
 13 |   }
 14 | 
 15 |   async function f1() {
 16 |     const a = await delayIdentity(10);
 17 |     const b = await delayIdentity(5);
 18 |     return a + b;
 19 |   }
 20 | 
 21 |   // const pa = Promise.resolve(10);
 22 |   const pa = f1();
 23 | 
 24 |   (async () => {
 25 |     // log(await pa);
 26 |     // log(await pa);
 27 |     // log(await pa);
 28 |   })();
 29 |   // f1();
 30 |   // f1().then(log);
 31 |   // go(f1(), log);
 32 |   // (async () => {
 33 |   //   log(await f1());
 34 |   // }) ();
 35 | </script>
 36 | 
 37 | ## QnA. Array.prototype.map이 있는데 왜 FxJS의 map 함수가 필요한지?
 38 | 
 39 | <script>
 40 |   function delayI(a) {
 41 |     return new Promise(resolve => setTimeout(() => resolve(a), 100));
 42 |   }
 43 | 
 44 |   async function f2() {
 45 |     const list = [1, 2, 3, 4];
 46 |     const temp = list.map(async a => await delayI(a * a));
 47 |     // log(temp);
 48 |     const res = await temp;
 49 |     // log(res);
 50 |   }
 51 | 
 52 |   f2();
 53 | 
 54 |   async function f3() {
 55 |     const list = [1, 2, 3, 4];
 56 |     const temp = map(a => delayI(a * a), list);
 57 |     // log(temp);
 58 |     const res = await temp;
 59 |     // log(res);
 60 |   }
 61 | 
 62 |   f3();
 63 | 
 64 |   function f4() {
 65 |     return map(a => delayI(a * a), [1, 2, 3, 4]);
 66 |   }
 67 | 
 68 |   (async () => {
 69 |     // log(await f4());
 70 |   })();
 71 | </script>
 72 | 
 73 | ## QnA. 이제 비동기는 async/await로 제어할 수 있는데 왜 파이프라인이 필요한지?
 74 | 
 75 | <script>
 76 |   function f5(list) {
 77 |     return go(list,
 78 |       L.map(a => delayI(a * a)),
 79 |       L.filter(a => delayI(a % 2)),
 80 |       L.map(a => delayI(a + 1)),
 81 |       C.take(2),
 82 |       reduce((a, b) => delayI(a + b)));
 83 |   }
 84 | 
 85 |   go(f5([1, 2, 3, 4, 5, 6, 7, 8]), a => log(a, 'f5'));
 86 | 
 87 |   async function f6(list) {
 88 |     let temp = [];
 89 |     for (const a of list) {
 90 |       const b = await delayI(a * a);
 91 |       if (await delayI(b % 2)) {
 92 |         const c = await delayI(b + 1);
 93 |         temp.push(c);
 94 |         if (temp.length == 2) break;
 95 |       }
 96 |     }
 97 |     let res = temp[0], i = 0;
 98 |     while (++i < temp.length) {
 99 |       res = await delayI(res + temp[i]);
100 |     }
101 |     return res;
102 |   }
103 | 
104 |   go(f6([1, 2, 3, 4, 5, 6, 7, 8]), log);
105 | </script>
106 | 
107 | ## QnA. async/await와 파이프라인을 같이 사용하기도 하나요?
108 | 
109 | <script>
110 |   async function f52(list) {
111 |     const r1 = await go(list,
112 |       L.map(a => delayI(a * a)),
113 |       L.filter(a => delayI(a % 2)),
114 |       L.map(a => delayI(a + 1)),
115 |       C.take(2),
116 |       reduce((a, b) => delayI(a + b)));
117 | 
118 |     const r2 = await go(list,
119 |       L.map(a => delayI(a * a)),
120 |       L.filter(a => delayI(a % 2)),
121 |       reduce((a, b) => delayI(a + b)));
122 | 
123 |     const r3 = await delayI(r1 + r2);
124 | 
125 |     return r3 + 10;
126 |   }
127 | 
128 |   go(f52([1, 2, 3, 4, 5, 6, 7, 8]), a => log(a, 'f52'));
129 | </script>
130 | 
131 | ## QnA. 동기 상황에서 에러 핸들링은 어떻게 해야하는지?
132 | 
133 | <script>
134 |   /*function f7(list) {
135 |     try {
136 |       return list
137 |         .map(a => JSON.parse(a))
138 |         .filter(a => a % 2)
139 |         .slice(0, 2);
140 |     } catch (e) {
141 |       log(e);
142 |       return [];
143 |     }
144 |   }
145 |   log(f7(['0', '1', '2', '{']));*/
146 | </script>
147 | 
148 | ## QnA. 비동기 상황에서 에러 핸들링은 어떻게 해야하는지?
149 | 
150 | <script>
151 |   /*async function f8(list) {
152 |     try {
153 |       return await list
154 |         .map(async a => await new Promise(resolve => {
155 |           resolve(JSON.parse(a));
156 |         }))
157 |         .filter(a => a % 2)
158 |         .slice(0, 2);
159 |     } catch (e) {
160 |       // log(e, '----------------------');
161 |       return [];
162 |     }
163 |   }
164 |   f8(['0', '1', '2', '{']).then(log).catch(e => {
165 |     log('에러 핸들링 하겠다.');
166 |   });*/
167 | </script>
168 | 
169 | ## QnA. 동기/비동기 에러 핸들링에서의 파이프라인의 이점은?
170 | 
171 | <script>
172 |   async function f9(list) {
173 |     try {
174 |       return await go(
175 |         list,
176 |         map(a => new Promise(resolve => {
177 |           resolve(JSON.parse(a));
178 |         })),
179 |         filter(a => a % 2),
180 |         take(2));
181 |     } catch (e) {
182 |       return [];
183 |     }
184 |   }
185 | 
186 |   // f9(['0', '1', '2', '3', '4', '{']).then(a => log(a, 'f9')).catch(e => {
187 |   //   log('에러 핸들링 하겠다.', e);
188 |   // });
189 | </script>
190 | 


--------------------------------------------------------------------------------
/11. 비동기 동시성 프로그래밍 3/1/lib/fx.js:
--------------------------------------------------------------------------------
  1 | const log = console.log;
  2 | 
  3 | const curry = f =>
  4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
  5 | 
  6 | const isIterable = a => a && a[Symbol.iterator];
  7 | 
  8 | const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);
  9 | 
 10 | const reduceF = (acc, a, f) =>
 11 |   a instanceof Promise ?
 12 |     a.then(a => f(acc, a), e => e == nop ? acc : Promise.reject(e)) :
 13 |     f(acc, a);
 14 | 
 15 | const head = iter => go1(take(1, iter), ([h]) => h);
 16 | 
 17 | const reduce = curry((f, acc, iter) => {
 18 |   if (!iter) return reduce(f, head(iter = acc[Symbol.iterator]()), iter);
 19 | 
 20 |   iter = iter[Symbol.iterator]();
 21 |   return go1(acc, function recur(acc) {
 22 |     let cur;
 23 |     while (!(cur = iter.next()).done) {
 24 |       acc = reduceF(acc, cur.value, f);
 25 |       if (acc instanceof Promise) return acc.then(recur);
 26 |     }
 27 |     return acc;
 28 |   });
 29 | });
 30 | 
 31 | const go = (...args) => reduce((a, f) => f(a), args);
 32 | 
 33 | const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
 34 | 
 35 | const take = curry((l, iter) => {
 36 |   let res = [];
 37 |   iter = iter[Symbol.iterator]();
 38 |   return function recur() {
 39 |     let cur;
 40 |     while (!(cur = iter.next()).done) {
 41 |       const a = cur.value;
 42 |       if (a instanceof Promise) {
 43 |         return a
 44 |           .then(a => (res.push(a), res).length == l ? res : recur())
 45 |           .catch(e => e == nop ? recur() : Promise.reject(e));
 46 |       }
 47 |       res.push(a);
 48 |       if (res.length == l) return res;
 49 |     }
 50 |     return res;
 51 |   }();
 52 | });
 53 | 
 54 | const takeAll = take(Infinity);
 55 | 
 56 | const L = {};
 57 | 
 58 | L.range = function* (l) {
 59 |   let i = -1;
 60 |   while (++i < l) yield i;
 61 | };
 62 | 
 63 | L.map = curry(function* (f, iter) {
 64 |   for (const a of iter) {
 65 |     yield go1(a, f);
 66 |   }
 67 | });
 68 | 
 69 | const nop = Symbol('nop');
 70 | 
 71 | L.filter = curry(function* (f, iter) {
 72 |   for (const a of iter) {
 73 |     const b = go1(a, f);
 74 |     if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(nop));
 75 |     else if (b) yield a;
 76 |   }
 77 | });
 78 | 
 79 | L.entries = function* (obj) {
 80 |   for (const k in obj) yield [k, obj[k]];
 81 | };
 82 | 
 83 | L.flatten = function* (iter) {
 84 |   for (const a of iter) {
 85 |     if (isIterable(a)) yield* a;
 86 |     else yield a;
 87 |   }
 88 | };
 89 | 
 90 | L.deepFlat = function* f(iter) {
 91 |   for (const a of iter) {
 92 |     if (isIterable(a)) yield* f(a);
 93 |     else yield a;
 94 |   }
 95 | };
 96 | 
 97 | L.flatMap = curry(pipe(L.map, L.flatten));
 98 | 
 99 | const map = curry(pipe(L.map, takeAll));
100 | 
101 | const filter = curry(pipe(L.filter, takeAll));
102 | 
103 | const find = curry((f, iter) => go(
104 |   iter,
105 |   L.filter(f),
106 |   take(1),
107 |   ([a]) => a));
108 | 
109 | const flatten = pipe(L.flatten, takeAll);
110 | 
111 | const flatMap = curry(pipe(L.map, flatten));
112 | 
113 | var add = (a, b) => a + b;
114 | 
115 | const range = l => {
116 |   let i = -1;
117 |   let res = [];
118 |   while (++i < l) {
119 |     res.push(i);
120 |   }
121 |   return res;
122 | };
123 | 
124 | const C = {};
125 | 
126 | function noop() {
127 | }
128 | 
129 | const catchNoop = ([...arr]) =>
130 |   (arr.forEach(a => a instanceof Promise ? a.catch(noop) : a), arr);
131 | 
132 | C.reduce = curry((f, acc, iter) => iter ?
133 |   reduce(f, acc, catchNoop(iter)) :
134 |   reduce(f, catchNoop(acc)));
135 | 
136 | C.take = curry((l, iter) => take(l, catchNoop(iter)));
137 | 
138 | C.takeAll = C.take(Infinity);
139 | 
140 | C.map = curry(pipe(L.map, C.takeAll));
141 | 
142 | C.filter = curry(pipe(L.filter, C.takeAll));


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 함수형 프로그래밍과 ES6+ 예제 코드
 2 | 
 3 | ## 강의 목록
 4 | 1. 함수형 자바스크립트 기본기
 5 |     1. 평가와 일급
 6 |     2. 일급 함수
 7 |     3. 고차 함수
 8 |     4. 부수효과와 순수 함수
 9 | 2. ES6에서의 순회와 이터러블/이터레이터 프로토콜
10 |     1. 기존과 달라진 ES6에서의 리스트 순회
11 |     2. Array, Set, Map을 통해 알아보는 이터러블/이터레이터 프로토콜
12 |     3. 사용자 정의 이터러블
13 |     4. 전개 연산자
14 | 3. 제너레이터와 이터레이터
15 |     1. 제너레이터와 이터레이터
16 |     2. odds
17 |     3. for...of, 전개 연산자, 구조 분해, 나머지 연산자
18 | 4. map, filter, reduce
19 |     1. map
20 |     2. 이터러블 프로토콜을 따른 map의 다형성 1
21 |     3. 이터러블 프로토콜을 따른 map의 다형성 2
22 |     4. filter
23 |     5. reduce
24 |     6. reduce 2
25 |     7. map+filter+reduce 중첩 사용과 함수형 사고
26 | 5. 코드를 값으로 다루어 표현력 높이기
27 |     1. go
28 |     2. pipe
29 |     3. go를 사용하여 읽기 좋은 코드로 만들기
30 |     4. go+curry를 사용하여 더 읽기 좋은 코드로 만들기
31 |     5. 함수 조합으로 함수 만들기
32 | 6. 장바구니 예제
33 |     1. 총 수량, 총 가격
34 |     2. HTML로 출력하기
35 | 7. 지연성 1
36 |     1. range와 느긋한 L.range
37 |     2. range와 느긋한 L.range 테스트
38 |     3. take
39 |     4. 제너레이터/이터레이터 프로토콜로 구현하는 지연 평가
40 |     5. L.map
41 |     6. L. filter
42 |     7. range, map, filter, take, reduce 중첩 사용
43 |     8. L.range, L.map, L.filter, take 의 평가 순서
44 |     9. 엄격한 계산과 느긋한 계산의 효율성 비교
45 |     10. map, filter 계열 함수들이 가지는 결합 법칙
46 |     11. ES6의 기본 규악을 통해 구현하는 지연 평가의 장점
47 | 8. 지연성 2
48 |     1. 결과를 만드는 함수 reduce, take
49 |     2. queryStr 함수 만들기
50 |     3. Array.prototype.join 보다 다형성이 높은 join 함수
51 |     4. take, find
52 |     5. L.map, L.filter로 map과 filter 만들기
53 |     6. L.flatten, flatten
54 |     7. L.flatMap, flatMap
55 |     8. 2차원 배열 다루기
56 |     9. 지연성 / 이터러블 중심 프로그래밍 실무적인 코드
57 | 9. 비동기/동시성 프로그래밍 1
58 |     1. callback과 Promise
59 |     2. 비동기를 값으로 만드는 Promise
60 |     3. 값으로서의 Promise 활용
61 |     4. 합성 관점에서의 Promise와 모나드
62 |     5. Kleisli Composition 관점에서의 Promise
63 |     6. go, pipe, reduce에서 비동기 제어
64 |     7. promise.then의 중요한 규칙
65 | 10. 비동기/동시성 프로그래밍 2
66 |     1. 지연 평가 + Promise - L.map, map, take
67 |     2. Kleisli Composition - L.filter, filter, nop, take
68 |     3. reduce에서 nop 지원
69 |     4. 지연 평가 + Promise의 효율성
70 |     5. 지연된 함수열을 병렬적으로 평가하기 - C.reduce, C.take 1
71 |     6. 지연된 함수열을 병렬적으로 평가하기 - C.reduce, C.take 2
72 |     7. 즉시 병렬적으로 평가하기 - C.map, C.filter
73 |     8. 즉시, 지연, Promise, 병렬적 조합하기
74 |     9. 코드 간단히 정리
75 |     10. Node.js에서 SQL 병렬 평가로 얻은 효율
76 | 11. 비동기/동시성 프로그래밍 3
77 |     1. async/await
78 |     2. Q&A) Array.prototype.map이 있는데 왜 FxJS의 map 함수가 필요한지?
79 |     3. Q&A) 이제 비동기는 async/await로 제어할 수 있는데 왜 파이프라인이 필요한지?
80 |     4. Q&A) async/await와 파이프라인을 같이 사용하기도 하는지?
81 |     5. Q&A) 동기 상황에서 에러 핸들링은 어떻게 해야하는지?
82 |     6. Q&A) 비동기 상황에서 에러 핸들링은 어떻게 해야하는지?
83 |     7. Q&A) 동기/비동기 에러 핸들링에서의 파이프라인의 이점은?
84 | 


--------------------------------------------------------------------------------
/fx.js:
--------------------------------------------------------------------------------
  1 | export const log = console.log;
  2 | 
  3 | export const curry = f =>
  4 |   (a, ..._) => _.length ? f(a, ..._) : (..._) => f(a, ..._);
  5 | 
  6 | export const isIterable = a => a && a[Symbol.iterator];
  7 | 
  8 | export const go1 = (a, f) => a instanceof Promise ? a.then(f) : f(a);
  9 | 
 10 | const reduceF = (acc, a, f) =>
 11 |   a instanceof Promise ?
 12 |     a.then(a => f(acc, a), e => e == nop ? acc : Promise.reject(e)) :
 13 |     f(acc, a);
 14 | 
 15 | export const head = iter => go1(take(1, iter), ([h]) => h);
 16 | 
 17 | export const reduce = curry((f, acc, iter) => {
 18 |   if (!iter) return reduce(f, head(iter = acc[Symbol.iterator]()), iter);
 19 | 
 20 |   iter = iter[Symbol.iterator]();
 21 |   return go1(acc, function recur(acc) {
 22 |     let cur;
 23 |     while (!(cur = iter.next()).done) {
 24 |       acc = reduceF(acc, cur.value, f);
 25 |       if (acc instanceof Promise) return acc.then(recur);
 26 |     }
 27 |     return acc;
 28 |   });
 29 | });
 30 | 
 31 | export const go = (...args) => reduce((a, f) => f(a), args);
 32 | 
 33 | export const pipe = (f, ...fs) => (...as) => go(f(...as), ...fs);
 34 | 
 35 | export const take = curry((l, iter) => {
 36 |   let res = [];
 37 |   iter = iter[Symbol.iterator]();
 38 |   return function recur() {
 39 |     let cur;
 40 |     while (!(cur = iter.next()).done) {
 41 |       const a = cur.value;
 42 |       if (a instanceof Promise) {
 43 |         return a
 44 |           .then(a => (res.push(a), res).length == l ? res : recur())
 45 |           .catch(e => e == nop ? recur() : Promise.reject(e));
 46 |       }
 47 |       res.push(a);
 48 |       if (res.length == l) return res;
 49 |     }
 50 |     return res;
 51 |   }();
 52 | });
 53 | 
 54 | export const takeAll = take(Infinity);
 55 | 
 56 | export const L = {};
 57 | 
 58 | L.range = function* (l) {
 59 |   let i = -1;
 60 |   while (++i < l) yield i;
 61 | };
 62 | 
 63 | L.map = curry(function* (f, iter) {
 64 |   for (const a of iter) {
 65 |     yield go1(a, f);
 66 |   }
 67 | });
 68 | 
 69 | export const nop = Symbol('nop');
 70 | 
 71 | L.filter = curry(function* (f, iter) {
 72 |   for (const a of iter) {
 73 |     const b = go1(a, f);
 74 |     if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(nop));
 75 |     else if (b) yield a;
 76 |   }
 77 | });
 78 | 
 79 | L.entries = function* (obj) {
 80 |   for (const k in obj) yield [k, obj[k]];
 81 | };
 82 | 
 83 | L.flatten = function* (iter) {
 84 |   for (const a of iter) {
 85 |     if (isIterable(a) && typeof a != 'string') yield* a;
 86 |     else yield a;
 87 |   }
 88 | };
 89 | 
 90 | L.deepFlat = function* f(iter) {
 91 |   for (const a of iter) {
 92 |     if (isIterable(a) && typeof a != 'string') yield* f(a);
 93 |     else yield a;
 94 |   }
 95 | };
 96 | 
 97 | L.flatMap = curry(pipe(L.map, L.flatten));
 98 | 
 99 | export const map = curry(pipe(L.map, takeAll));
100 | 
101 | export const filter = curry(pipe(L.filter, takeAll));
102 | 
103 | export const find = curry((f, iter) => go(
104 |   iter,
105 |   L.filter(f),
106 |   take(1),
107 |   ([a]) => a));
108 | 
109 | export const flatten = pipe(L.flatten, takeAll);
110 | 
111 | export const flatMap = curry(pipe(L.map, flatten));
112 | 
113 | export const add = (a, b) => a + b;
114 | 
115 | export const range = l => {
116 |   let i = -1;
117 |   let res = [];
118 |   while (++i < l) {
119 |     res.push(i);
120 |   }
121 |   return res;
122 | };
123 | 
124 | export const C = {};
125 | 
126 | export function noop() {
127 | }
128 | 
129 | const catchNoop = ([...arr]) =>
130 |   (arr.forEach(a => a instanceof Promise ? a.catch(noop) : a), arr);
131 | 
132 | C.reduce = curry((f, acc, iter) => iter ?
133 |   reduce(f, acc, catchNoop(iter)) :
134 |   reduce(f, catchNoop(acc)));
135 | 
136 | C.take = curry((l, iter) => take(l, catchNoop(iter)));
137 | 
138 | C.takeAll = C.take(Infinity);
139 | 
140 | C.map = curry(pipe(L.map, C.takeAll));
141 | 
142 | C.filter = curry(pipe(L.filter, C.takeAll));


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require('esm')(module)('./fx.js');


--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
  1 | const { expect } = require('chai');
  2 | 
  3 | Object.assign(global, require('../index.js'));
  4 | 
  5 | describe('take', function () {
  6 |   it('take(1, [1, 2, 3])', () => {
  7 |     expect(take(1, [1, 2, 3])).to.eql([1]);
  8 |   });
  9 |   it('take(2, [1, 2, 3])', () => {
 10 |     expect(take(2, [1, 2, 3])).to.eql([1, 2]);
 11 |   });
 12 | 
 13 |   it('take(2, L.map(a => a + 1, [1, 2, 3]))', () => {
 14 |     expect(take(2, L.map(a => a + 1, [1, 2, 3]))).to.eql([2, 3]);
 15 |   });
 16 | 
 17 |   it('take(2, L.filter(a => a % 2, [1, 2, 3, 4, 5]))', () => {
 18 |     expect(take(2, L.filter(a => a % 2, [1, 2, 3, 4, 5]))).to.eql([1, 3]);
 19 |   });
 20 | 
 21 |   it('take(2, L.map(a => Promise.resolve(a + 1), [1, 2, 3]))', () => {
 22 |     go1(
 23 |       take(2, L.map(a => Promise.resolve(a + 1), [1, 2, 3])),
 24 |       _ => expect(_).to.eql([2, 3])
 25 |     );
 26 |   });
 27 | 
 28 |   it('take(2, L.filter(a => Promise.resolve(a % 2), [1, 2, 3, 4, 5]))', () => {
 29 |     go1(
 30 |       take(2, L.filter(a => Promise.resolve(a % 2), [1, 2, 3])),
 31 |       _ => expect(_).to.eql([1, 3])
 32 |     );
 33 |   });
 34 | });
 35 | 
 36 | describe('reduce', function () {
 37 |   const add = (a, b) => a + b;
 38 |   it('reduce(add, [1, 2, 3])', () => {
 39 |     expect(reduce(add, [1, 2, 3])).to.eql(6);
 40 |   });
 41 |   it('reduce(add, 10, [1, 2, 3])', () => {
 42 |     expect(reduce(add, 10, [1, 2, 3])).to.eql(16);
 43 |   });
 44 |   it('reduce(add, [Promise.resolve(1), 2, 3])', () => {
 45 |     go1(reduce(add, [Promise.resolve(1), 2, 3]), _ => expect(_).to.eql(6));
 46 |   });
 47 |   it('reduce(add, L.filter(a => a % 2, [1, 2, 3, 4]))', () => {
 48 |     expect(reduce(add, L.filter(a => a % 2, [1, 2, 3, 4]))).to.eql(4);
 49 |   });
 50 |   it('reduce(add, L.filter(a => Promise.resolve(a % 2), [1, 2, 3, 4]))', () => {
 51 |     go1(reduce(add, L.filter(a => Promise.resolve(a % 2), [1, 2, 3, 4])), _ => expect(_).to.eql(4));
 52 |   });
 53 |   it('reduce(add, L.filter(a => Promise.resolve(a % 2), L.map(a => a + 10, [1, 2, 3, 4])))', () => {
 54 |     go1(reduce(add, L.filter(a => Promise.resolve(a % 2), L.map(a => a + 10, [1, 2, 3, 4]))), _ => expect(_).to.eql(24));
 55 |   });
 56 |   it('reduce(add, L.filter(a => Promise.resolve(a % 2), L.map(a => Promise.resolve(a + 10), [1, 2, 3, 4])))', () => {
 57 |     go1(reduce(add, L.filter(a => Promise.resolve(a % 2), L.map(a => Promise.resolve(a + 10), [1, 2, 3, 4]))), _ => expect(_).to.eql(24));
 58 |   });
 59 | });
 60 | 
 61 | describe('C.take', function () {
 62 |   function delay(val, time = 1000) {
 63 |     return new Promise(resolve => setTimeout(_ => resolve(val), time));
 64 |   }
 65 | 
 66 |   it('C.take(2, L.map(a => delay(a, a * 100), [1, 2, 3]))', () => {
 67 |     go1(
 68 |       C.take(2, L.map(a => delay(a, 100), [1, 2, 3])),
 69 |       _ => expect(_).to.eql([1, 2])
 70 |     );
 71 |   });
 72 | 
 73 |   it('C.take(2, L.filter(a => delay(a % 2, a * 100), [1, 2, 3]))', () => {
 74 |     go1(
 75 |       C.take(2, L.filter(a => delay(a % 2, 100), [1, 2, 3])),
 76 |       _ => expect(_).to.eql([1, 3])
 77 |     );
 78 |   });
 79 | });
 80 | 
 81 | describe('map', function () {
 82 |   return;
 83 |   function delay(val, time = 1000) {
 84 |     return new Promise(resolve => setTimeout(_ => resolve(val), time));
 85 |   }
 86 | 
 87 |   it('map(a => delay(a+10, 1000), [1, 2, 3])', async function() {
 88 |     expect(await map(a => a + 10, [Promise.resolve(1), 2, 3])).to.eql([11, 12, 13]);
 89 |   });
 90 | 
 91 |   it('map(a => delay(a+10, 1000), [1, 2, 3])', async function() {
 92 |     this.timeout(5000);
 93 |     expect(await map(a => delay(a+10, 1000), [1, 2, 3])).to.eql([11, 12, 13]);
 94 |   });
 95 | 
 96 |   it('C.map(a => delay(a+10, 1000), [1, 2, 3])', async function() {
 97 |     this.timeout(1500);
 98 |     expect(await C.map(a => delay(a+10, 1000), [1, 2, 3])).to.eql([11, 12, 13]);
 99 |   });
100 | });
101 | 
102 | describe('find', function () {
103 |   it('find(a => a > 1, [1, 2, 3])', function() {
104 |     expect(find(a => a > 1, [1, 2, 3])).to.eql(2);
105 |   });
106 | });
107 | 
108 | describe('go', function () {
109 |   it(`
110 |     go(
111 |       0,
112 |       a => a + 1,
113 |       a => a + 10,
114 |       a => a + 100)`, function () {
115 |     expect(
116 |       go(
117 |         0,
118 |         a => a + 1,
119 |         a => a + 10,
120 |         a => a + 100)).to.eql(111)
121 |   });
122 | 
123 |   it(`
124 |     go(
125 |       0,
126 |       a => { throw { hi: 'ho' } },
127 |       a => a + 10,
128 |       a => a + 100)`, function () {
129 |     try {
130 |       go(
131 |         0,
132 |         a => { throw { hi: 'ho' } },
133 |         a => a + 10,
134 |         a => a + 100)
135 |     } catch (a) {
136 |       expect(a).to.eql({ hi: 'ho' })
137 |     }
138 |   });
139 | 
140 |   it(`
141 |     go(
142 |       0,
143 |       a => Promise.resolve(a + 1),
144 |       a => a + 10,
145 |       a => a + 100)`, async function () {
146 |       expect(
147 |         await go(
148 |           0,
149 |           a => Promise.resolve(a + 1),
150 |           a => a + 10,
151 |           a => a + 100)).to.eql(111)
152 |   });
153 | 
154 |   it(`
155 |     go(
156 |       0,
157 |       a => Promise.resolve(a + 1),
158 |       a => Promise.reject({ hi: 'ho' }),
159 |       a => a + 100)`, async function () {
160 |       try {
161 |         await go(
162 |           0,
163 |           a => Promise.resolve(a + 1),
164 |           a => Promise.reject({ hi: 'ho' }),
165 |           a => a + 100)
166 |       } catch (a) {
167 |         expect(a).to.eql({ hi: 'ho' })
168 |       }
169 |   });
170 | 
171 |   it(`
172 |     go(
173 |       0,
174 |       a => Promise.resolve(a + 1),
175 |       a => { throw { hi: 'ho' } },
176 |       a => a + 100)`, async function () {
177 |       try {
178 |         await go(
179 |           0,
180 |           a => Promise.resolve(a + 1),
181 |           a => { throw { hi: 'ho' } },
182 |           a => a + 100)
183 |       } catch (a) {
184 |         expect(a).to.eql({ hi: 'ho' })
185 |       }
186 |   });
187 | });


--------------------------------------------------------------------------------