01/1

├── .gitignore ├── 01. 이터러블 프로그래밍 혹은 리스트 프로세싱 └── 1.html ├── 02. 명령형 습관 지우기 └── 1.html ├── 03. 안전한 합성에 대해 └── 1.html ├── 04. 객체를 이터러블 프로그래밍으로 다루기 └── 1.html ├── 05. 사용자 정의 객체를 이터러블 프로그래밍으로 다루기 └── 1.html ├── 06. 시간을 이터러블로 다루기 └── 1.html ├── 07. 프론트엔드에서 함수형 이터러블 동시성 프로그래밍 └── 1.html ├── README.md └── fx.js /.gitignore: -------------------------------------------------------------------------------- 1 | *.xml 2 | *.iml -------------------------------------------------------------------------------- /01. 이터러블 프로그래밍 혹은 리스트 프로세싱/1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 01/1 6 | 7 | 8 | 9 | 10 | # 함수형 프로그래밍과 JavaScript ES6+ 응용편 11 | 12 | ## 이터러블 프로그래밍 혹은 리스트 프로세싱 (Lisp) 13 | 14 | 1. 홀수 n개 더하기 15 | 16 | 30 | 31 | 2. if를 filter로 32 | 3. 값 변화 후 변수 할당을 map으로 33 | 4. break를 take로 34 | 5. 축약 및 합산을 reduce로 35 | 36 | 50 | 51 | 6. while을 range로 52 | 7. 효과를 each로 구분 53 | 54 | 73 | 74 | 8. 추억의 별 그리기, 구구단 75 | 76 | 106 | 107 | 108 | -------------------------------------------------------------------------------- /02. 명령형 습관 지우기/1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 02/1 6 | 7 | 8 | 9 | 10 | ## 명령형 습관 지우기 - 만능 reduce? No! 11 | 12 | 1. reduce + 복잡한 함수 + acc 보다 map + 간단한 함수 + reduce 13 | 14 | 34 | 35 | 2. reduce 하나 보다 map + filter + reduce 36 | 37 | 55 | 56 | 3. query 57 | 58 | 115 | 116 | 4. queryToObject 117 | 118 | 129 | 130 | 131 | 132 | -------------------------------------------------------------------------------- /03. 안전한 합성에 대해/1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 03/1 6 | 7 | 8 | 9 | 10 | ## 안전한 합성에 대해 11 | 12 | 1. map으로 합성하기 13 | 14 | 36 | 37 | 2. find 대신 L.filter 써보기 38 | 39 | 63 | 64 | 65 | -------------------------------------------------------------------------------- /04. 객체를 이터러블 프로그래밍으로 다루기/1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 04/1 6 | 7 | 8 | 9 | 10 | ## 객체를 이터러블 프로그래밍으로 다루기 11 | 12 | 20 | 21 | 1. values 22 | 23 | 42 | 43 | 2. entries 44 | 45 | 62 | 63 | 3. keys 64 | 65 | 79 | 80 | 4. 어떠한 값이든 이터러블 프로그래밍으로 다루기 81 | - 이터러블로 이터러블 프로그래밍 82 | - 객체를 제너레이터를 이용해서 이터레이터로 만들어서 이터러블 프로그래밍 83 | - 어떤 제너레이터든 이터레이터로 만들어서 이터러블 프로그래밍 84 | 85 | 106 | 107 | 5. object 108 | 109 | 131 | 132 | 6. mapObject 133 | 134 | 148 | 149 | 7. pick 150 | 151 | 164 | 165 | 8. indexBy 166 | 167 | 184 | 185 | 9. indexBy 된 값을 filter 하기 186 | 187 | 198 | 199 | 200 | -------------------------------------------------------------------------------- /05. 사용자 정의 객체를 이터러블 프로그래밍으로 다루기/1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 05/1 6 | 7 | 8 | 9 | 10 | ## 사용자 정의 객체를 이터러블 프로그래밍으로 다루기 11 | 12 | 1. Map, Set 13 | 14 | 37 | 38 | 2. Model, Collection 39 | 40 | 87 | 88 | 3. Product, Products 89 | 90 | 113 | 114 | 115 | -------------------------------------------------------------------------------- /06. 시간을 이터러블로 다루기/1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 06/1 6 | 7 | 8 | 9 | 10 | ## 시간을 이터러블로 다루기 11 | 12 | 1. range와 take의 재해석 13 | 14 | 30 | 31 | 2. takeWhile, takeUntil 32 | 33 | 51 | 52 | 3. 할 일들을 이터러블(리스트)로 바라보기 53 | 54 | 76 | 77 | 4. 아임포트 결제 누락 스케쥴러 만들기 78 | 79 | 153 | 154 | 155 | -------------------------------------------------------------------------------- /07. 프론트엔드에서 함수형 이터러블 동시성 프로그래밍/1.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 07/1 6 | 7 | 110 | 111 | 112 | 113 | 130 | 131 | 136 | 137 | 163 | 164 | 214 | 215 | 270 | 271 | 272 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 함수형 프로그래밍과 Javascript ES6+ 응용편 2 | 3 | ## 강의 링크 4 | - [영상 강의 보러 가기](https://www.inflearn.com/course/함수형_ES6_응용편) 5 | 6 | ## 강의 목록 7 | 8 | 1. 이터러블 프로그래밍 혹은 리스트 프로세싱 (Lisp) 9 | 1. 들어가며 10 | 2. 홀수 n개 더하기 11 | 3. if를 filter로 12 | 4. 값 변화 후 변수 할당을 map으로 13 | 5. break를 take로 14 | 6. 축약 및 합산을 reduce로 15 | 7. while을 range로 16 | 8. 효과를 each로 구분 17 | 9. 추억의 별 그리기 18 | 10. 추억의 구구단 19 | 2. 명령형 습관 지우기 - 만능 reduce? No! 20 | 1. reduce + 복잡한 함수 + acc 보다 map + 간단한 함수 + reduce 21 | 2. reduce 하나 보다 map + filter + reduce 22 | 3. query, queryToObject 23 | 3. 안전한 합성에 대해 24 | 1. map으로 합성하기 25 | 2. find 대신 L.filter 써보기 26 | 4. 객체를 이터러블 프로그래밍으로 다루기 27 | 1. values 28 | 2. entries 29 | 3. keys 30 | 4. 어떠한 값이든 이터러블 프로그래밍으로 다루기 31 | 5. object 32 | 6. mapObject 33 | 7. pick 34 | 8. indexBy 35 | 9. indexBy 된 값을 filter 하기 36 | 5. 객체지향과 함께 사용하기 - 사용자 정의 객체를 이터러블 프로그래밍으로 37 | 1. Map, Set, NodeList 38 | 2. Model, Collection 클래스 만들어서 이터러블 프로토콜 지원하기 39 | 3. Product, Products - 메서드를 함수형으로 구현하기 40 | 6. 시간을 이터러블로 다루기 41 | 1. range와 take의 재해석 42 | 2. takeWhile, takeUntil 43 | 3. 자동차 경주 - 할 일들을 이터러블(리스트)로 바라보기 44 | 4. 아임포트 결제 누락 처리 스케쥴러 - API 설명 45 | 5. 아임포트 결제 누락 처리 스케쥴러 - 결제된 내역 가져오기 46 | 6. 아임포트 결제 누락 처리 스케쥴러 - 가맹점 DB의 주문서 가져오기 47 | 7. 아임포트 결제 누락 처리 스케쥴러 - 비교 후 결제 취소 API 실행하기 48 | 8. 아임포트 결제 누락 처리 스케쥴러 - 반복 실행하기 49 | 7. 프론트엔드에서 함수형/이터러블/동시성 프로그래밍 50 | 1. ES6 템플릿 리터럴 활용 51 | 2. 이미지 목록 그리기 52 | 3. 아이템 지우기 53 | 4. 커스텀 confirm 창과 Promise 54 | 5. 클래스를 대신 함수로 하는 추상화 55 | 6. 이미지 동시성 다루기 56 | 7. 동시성 부하 조절 57 | 8. 고차 함수로 더 작게 나누어 재사용성 높이기 - 데이터형 없애기 58 | 9. 상위 스코프 변수를 사용하는 함수와 아닌 함수들 쪼개기 59 | 10. DOM을 다루는 고차 함수 -------------------------------------------------------------------------------- /fx.js: -------------------------------------------------------------------------------- 1 | /******/ (function(modules) { // webpackBootstrap 2 | /******/ // The module cache 3 | /******/ var installedModules = {}; 4 | /******/ 5 | /******/ // The require function 6 | /******/ function __webpack_require__(moduleId) { 7 | /******/ 8 | /******/ // Check if module is in cache 9 | /******/ if(installedModules[moduleId]) { 10 | /******/ return installedModules[moduleId].exports; 11 | /******/ } 12 | /******/ // Create a new module (and put it into the cache) 13 | /******/ var module = installedModules[moduleId] = { 14 | /******/ i: moduleId, 15 | /******/ l: false, 16 | /******/ exports: {} 17 | /******/ }; 18 | /******/ 19 | /******/ // Execute the module function 20 | /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 21 | /******/ 22 | /******/ // Flag the module as loaded 23 | /******/ module.l = true; 24 | /******/ 25 | /******/ // Return the exports of the module 26 | /******/ return module.exports; 27 | /******/ } 28 | /******/ 29 | /******/ 30 | /******/ // expose the modules object (__webpack_modules__) 31 | /******/ __webpack_require__.m = modules; 32 | /******/ 33 | /******/ // expose the module cache 34 | /******/ __webpack_require__.c = installedModules; 35 | /******/ 36 | /******/ // define getter function for harmony exports 37 | /******/ __webpack_require__.d = function(exports, name, getter) { 38 | /******/ if(!__webpack_require__.o(exports, name)) { 39 | /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 40 | /******/ } 41 | /******/ }; 42 | /******/ 43 | /******/ // define __esModule on exports 44 | /******/ __webpack_require__.r = function(exports) { 45 | /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 46 | /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 47 | /******/ } 48 | /******/ Object.defineProperty(exports, '__esModule', { value: true }); 49 | /******/ }; 50 | /******/ 51 | /******/ // create a fake namespace object 52 | /******/ // mode & 1: value is a module id, require it 53 | /******/ // mode & 2: merge all properties of value into the ns 54 | /******/ // mode & 4: return value when already ns object 55 | /******/ // mode & 8|1: behave like require 56 | /******/ __webpack_require__.t = function(value, mode) { 57 | /******/ if(mode & 1) value = __webpack_require__(value); 58 | /******/ if(mode & 8) return value; 59 | /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 60 | /******/ var ns = Object.create(null); 61 | /******/ __webpack_require__.r(ns); 62 | /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 63 | /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 64 | /******/ return ns; 65 | /******/ }; 66 | /******/ 67 | /******/ // getDefaultExport function for compatibility with non-harmony modules 68 | /******/ __webpack_require__.n = function(module) { 69 | /******/ var getter = module && module.__esModule ? 70 | /******/ function getDefault() { return module['default']; } : 71 | /******/ function getModuleExports() { return module; }; 72 | /******/ __webpack_require__.d(getter, 'a', getter); 73 | /******/ return getter; 74 | /******/ }; 75 | /******/ 76 | /******/ // Object.prototype.hasOwnProperty.call 77 | /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 78 | /******/ 79 | /******/ // __webpack_public_path__ 80 | /******/ __webpack_require__.p = ""; 81 | /******/ 82 | /******/ 83 | /******/ // Load entry module and return exports 84 | /******/ return __webpack_require__(__webpack_require__.s = 0); 85 | /******/ }) 86 | /************************************************************************/ 87 | /******/ ([ 88 | /* 0 */ 89 | /***/ (function(module, __webpack_exports__, __webpack_require__) { 90 | 91 | "use strict"; 92 | __webpack_require__.r(__webpack_exports__); 93 | var L_namespaceObject = {}; 94 | __webpack_require__.r(L_namespaceObject); 95 | __webpack_require__.d(L_namespaceObject, "L", function() { return L; }); 96 | __webpack_require__.d(L_namespaceObject, "deepFlatLazy", function() { return deepFlatLazy; }); 97 | __webpack_require__.d(L_namespaceObject, "entriesLazy", function() { return entriesLazy; }); 98 | __webpack_require__.d(L_namespaceObject, "mapEntriesLazy", function() { return Lazy_mapEntriesLazy; }); 99 | __webpack_require__.d(L_namespaceObject, "filterLazy", function() { return Lazy_filterLazy; }); 100 | __webpack_require__.d(L_namespaceObject, "flatLazy", function() { return flatLazy; }); 101 | __webpack_require__.d(L_namespaceObject, "flatMapLazy", function() { return Lazy_flatMapLazy; }); 102 | __webpack_require__.d(L_namespaceObject, "headTailLazy", function() { return headTailLazy; }); 103 | __webpack_require__.d(L_namespaceObject, "indexValuesLazy", function() { return indexValuesLazy; }); 104 | __webpack_require__.d(L_namespaceObject, "keysLazy", function() { return keysLazy; }); 105 | __webpack_require__.d(L_namespaceObject, "mapLazy", function() { return Lazy_mapLazy; }); 106 | __webpack_require__.d(L_namespaceObject, "rangeLazy", function() { return rangeLazy; }); 107 | __webpack_require__.d(L_namespaceObject, "rejectLazy", function() { return Lazy_rejectLazy; }); 108 | __webpack_require__.d(L_namespaceObject, "reverseLazy", function() { return reverseLazy; }); 109 | __webpack_require__.d(L_namespaceObject, "valuesLazy", function() { return valuesLazy; }); 110 | __webpack_require__.d(L_namespaceObject, "takeLazy", function() { return Lazy_takeLazy; }); 111 | __webpack_require__.d(L_namespaceObject, "takeWhileLazy", function() { return Lazy_takeWhileLazy; }); 112 | __webpack_require__.d(L_namespaceObject, "takeUntilLazy", function() { return Lazy_takeUntilLazy; }); 113 | __webpack_require__.d(L_namespaceObject, "intervalLazy", function() { return intervalLazy; }); 114 | __webpack_require__.d(L_namespaceObject, "dropLazy", function() { return Lazy_dropLazy; }); 115 | var C_namespaceObject = {}; 116 | __webpack_require__.r(C_namespaceObject); 117 | __webpack_require__.d(C_namespaceObject, "C", function() { return C; }); 118 | __webpack_require__.d(C_namespaceObject, "tailC", function() { return tailC; }); 119 | __webpack_require__.d(C_namespaceObject, "reduceC", function() { return Concurrency_reduceC; }); 120 | __webpack_require__.d(C_namespaceObject, "takeC", function() { return Concurrency_takeC; }); 121 | __webpack_require__.d(C_namespaceObject, "mapEntriesC", function() { return Concurrency_mapEntriesC; }); 122 | __webpack_require__.d(C_namespaceObject, "findC", function() { return Concurrency_findC; }); 123 | __webpack_require__.d(C_namespaceObject, "mapC", function() { return Concurrency_mapC; }); 124 | __webpack_require__.d(C_namespaceObject, "everyC", function() { return Concurrency_everyC; }); 125 | __webpack_require__.d(C_namespaceObject, "filterC", function() { return Concurrency_filterC; }); 126 | __webpack_require__.d(C_namespaceObject, "takeAllC", function() { return takeAllC; }); 127 | __webpack_require__.d(C_namespaceObject, "headC", function() { return headC; }); 128 | __webpack_require__.d(C_namespaceObject, "take1C", function() { return take1C; }); 129 | __webpack_require__.d(C_namespaceObject, "callsC", function() { return callsC; }); 130 | __webpack_require__.d(C_namespaceObject, "someC", function() { return Concurrency_someC; }); 131 | __webpack_require__.d(C_namespaceObject, "dropC", function() { return Concurrency_dropC; }); 132 | 133 | // CONCATENATED MODULE: ./curry.js 134 | function curry(f) { 135 | return (a, ..._) => _.length < 1 ? (..._) => f(a, ..._) : f(a, ..._); 136 | } 137 | // CONCATENATED MODULE: ./empty.js 138 | /* harmony default export */ var empty = (function *() {} ()); 139 | 140 | // CONCATENATED MODULE: ./toIter.js 141 | 142 | 143 | function toIter(iterable) { 144 | return iterable && iterable[Symbol.iterator] ? iterable[Symbol.iterator]() : empty; 145 | } 146 | // CONCATENATED MODULE: ./nop.js 147 | const nop = Symbol.for('nop'); 148 | 149 | /* harmony default export */ var nop_0 = (nop); 150 | // CONCATENATED MODULE: ./go1.js 151 | function go1(a, f) { 152 | return a instanceof Promise ? a.then(f) : f(a); 153 | } 154 | // CONCATENATED MODULE: ./take.js 155 | 156 | 157 | 158 | 159 | /* harmony default export */ var take_0 = (curry(function take(l, iter) { 160 | if (l < 1) return []; 161 | let res = []; 162 | iter = toIter(iter); 163 | return function recur() { 164 | let cur; 165 | while (!(cur = iter.next()).done) { 166 | const a = cur.value; 167 | if (a instanceof Promise) { 168 | return a 169 | .then(a => (res.push(a), res).length == l ? res : recur()) 170 | .catch(e => e == nop_0 ? recur() : Promise.reject(e)); 171 | } 172 | res.push(a); 173 | if (res.length == l) return res; 174 | } 175 | return res; 176 | } (); 177 | })); 178 | // CONCATENATED MODULE: ./head.js 179 | 180 | 181 | 182 | function head(iter) { 183 | return go1(take_0(1, iter), ([h]) => h); 184 | } 185 | // CONCATENATED MODULE: ./reduce.js 186 | 187 | 188 | 189 | 190 | 191 | const call2 = (acc, a, f) => 192 | a instanceof Promise ? 193 | a.then(a => f(acc, a), e => e == nop_0 ? acc : Promise.reject(e)) : 194 | f(acc, a); 195 | 196 | function reduce(f, acc, iter) { 197 | if (arguments.length == 1) return (..._) => reduce(f, ..._); 198 | if (arguments.length == 2) return reduce(f, head(iter = toIter(acc)), iter); 199 | 200 | iter = toIter(iter); 201 | return go1(acc, function recur(acc) { 202 | let cur; 203 | while (!(cur = iter.next()).done) { 204 | acc = call2(acc, cur.value, f); 205 | if (acc instanceof Promise) return acc.then(recur); 206 | } 207 | return acc; 208 | }); 209 | } 210 | // CONCATENATED MODULE: ./minBy.js 211 | 212 | 213 | 214 | /* harmony default export */ var minBy_0 = (curry(function minBy(f, iter) { 215 | return reduce((a, b) => f(a) <= f(b) ? a : b, iter); 216 | })); 217 | // CONCATENATED MODULE: ./call.js 218 | function call(a, f) { 219 | return f(a); 220 | } 221 | // CONCATENATED MODULE: ./pipe.js 222 | 223 | 224 | 225 | function pipe(f, ...fs) { 226 | return (...as) => reduce(call, f(...as), fs); 227 | } 228 | // CONCATENATED MODULE: ./isArray.js 229 | const { isArray } = Array; 230 | 231 | /* harmony default export */ var isArray_0 = (isArray); 232 | // CONCATENATED MODULE: ./baseSortBy.js 233 | 234 | 235 | 236 | const arrComparator = (arr) => (a, b) => { 237 | let i = -1; 238 | while (++i < arr.length) { 239 | const ai = a[arr[i]], bi = b[arr[i]]; 240 | if (ai === bi) continue; 241 | return ai < bi ? -1 : 1; 242 | } 243 | return 0; 244 | }; 245 | 246 | function baseSortBy(left, right, f, arr) { 247 | return isArray_0(f) ? baseSortBy(left, right, arrComparator(f), arr) : 248 | typeof f == 'string' ? baseSortBy(left, right, a => a[f], arr) : 249 | f.length == 2 ? [...arr].sort(right == -1 ? pipe(f, n => n * -1) : f) : 250 | [...arr].sort((a, b, fa = f(a), fb = f(b)) => fa == fb ? 0 : fa < fb ? left : right) 251 | } 252 | // CONCATENATED MODULE: ./sortByDesc.js 253 | 254 | 255 | 256 | /* harmony default export */ var sortByDesc_0 = (curry(function sortByDesc(f, arr) { 257 | return baseSortBy(1, -1, f, arr); 258 | })); 259 | // CONCATENATED MODULE: ./sortDesc.js 260 | 261 | 262 | function sort(arr) { 263 | return sortByDesc_0(a => a, arr); 264 | } 265 | // CONCATENATED MODULE: ./go.js 266 | 267 | 268 | 269 | function go(..._) { 270 | return reduce(call, _); 271 | } 272 | // CONCATENATED MODULE: ./isStop.js 273 | const SymbolStop = Symbol.for('stop'); 274 | 275 | function isStop(a) { 276 | return !!(a && a[SymbolStop]); 277 | } 278 | // CONCATENATED MODULE: ./reduceS.js 279 | 280 | 281 | 282 | 283 | 284 | 285 | const reduceS_call2 = (acc, a, f) => 286 | a instanceof Promise ? 287 | a.then(a => f(acc, a), e => e == nop_0 ? acc : Promise.reject(e)) : 288 | f(acc, a); 289 | 290 | function reduceS(f, acc, iter) { 291 | if (arguments.length == 1) return (..._) => reduceS(f, ..._); 292 | if (arguments.length == 2) return reduceS(f, head(iter = toIter(acc)), iter); 293 | 294 | iter = toIter(iter); 295 | return go1(acc, function recur(acc) { 296 | let cur; 297 | while (!isStop(acc) && !(cur = iter.next()).done) { 298 | acc = reduceS_call2(acc, cur.value, f); 299 | if (acc instanceof Promise) return acc.then(recur); 300 | } 301 | return isStop(acc) ? acc.value : acc; 302 | }); 303 | } 304 | // CONCATENATED MODULE: ./goS.js 305 | 306 | 307 | 308 | function goS(..._) { 309 | return reduceS(call, _); 310 | } 311 | // CONCATENATED MODULE: ./identity.js 312 | /* harmony default export */ var identity = (a => a); 313 | // CONCATENATED MODULE: ./stop.js 314 | const stop_SymbolStop = Symbol.for('stop'); 315 | 316 | function stop(value) { 317 | return { [stop_SymbolStop]: true, value }; 318 | } 319 | // CONCATENATED MODULE: ./Lazy/valuesLazy.js 320 | function *valuesLazy(obj) { 321 | for (const k in obj) yield obj[k]; 322 | } 323 | // CONCATENATED MODULE: ./takeAll.js 324 | 325 | 326 | function takeAll(iter) { 327 | return take_0(Infinity, iter); 328 | } 329 | // CONCATENATED MODULE: ./values.js 330 | 331 | 332 | 333 | function values(a) { 334 | return takeAll(valuesLazy(a)); 335 | } 336 | // CONCATENATED MODULE: ./safety.js 337 | 338 | 339 | function safety(a) { 340 | return a != null && !!a[Symbol.iterator] ? a : empty; 341 | } 342 | // CONCATENATED MODULE: ./Lazy/filterLazy.js 343 | 344 | 345 | 346 | 347 | 348 | /* harmony default export */ var Lazy_filterLazy = (curry(function *filterLazy(f, iter) { 349 | for (const a of safety(iter)) { 350 | const b = go1(a, f); 351 | if (b instanceof Promise) yield b.then(b => b ? a : Promise.reject(nop_0)); 352 | else if (b) yield a; 353 | } 354 | })); 355 | // CONCATENATED MODULE: ./find.js 356 | 357 | 358 | 359 | 360 | /* harmony default export */ var find_0 = (curry(function find(f, iter) { 361 | return head(Lazy_filterLazy(f, iter)); 362 | })); 363 | // CONCATENATED MODULE: ./not.js 364 | function not(a) { 365 | return !a; 366 | } 367 | // CONCATENATED MODULE: ./Lazy/rejectLazy.js 368 | 369 | 370 | 371 | 372 | 373 | /* harmony default export */ var Lazy_rejectLazy = (curry(function rejectLazy(f, iter) { 374 | return Lazy_filterLazy(a => go1(f(a), not), iter); 375 | })); 376 | // CONCATENATED MODULE: ./take1.js 377 | 378 | 379 | const take1 = take_0(1); 380 | 381 | /* harmony default export */ var take1_0 = (take1); 382 | // CONCATENATED MODULE: ./every.js 383 | 384 | 385 | 386 | 387 | 388 | /* harmony default export */ var every_0 = (curry(function every(f, iter) { 389 | return go1(take1_0(Lazy_rejectLazy(f, iter)), ({length}) => length == 0); 390 | })); 391 | // CONCATENATED MODULE: ./Lazy/entriesLazy.js 392 | function *entriesLazy(obj) { 393 | for (const k in obj) yield [k, obj[k]]; 394 | } 395 | // CONCATENATED MODULE: ./isMatch.js 396 | 397 | 398 | 399 | 400 | 401 | /* harmony default export */ var isMatch_0 = (curry(function isMatch(a, b) { 402 | return ( 403 | typeof a == 'function' ? !!a(b) 404 | : 405 | isArray_0(a) && isArray_0(b) ? every_0(v => b.includes(v), a) 406 | : 407 | typeof b == 'object' ? every_0(([k, v]) => b[k] == v, entriesLazy(a)) 408 | : 409 | a instanceof RegExp ? b.match(a) 410 | : 411 | a == b 412 | ); 413 | })); 414 | // CONCATENATED MODULE: ./match.js 415 | 416 | 417 | 418 | 419 | 420 | 421 | function baseMatch(targets) { 422 | var cbs = []; 423 | 424 | function evl() { 425 | return go( 426 | targets, 427 | values, 428 | targets => 429 | go(cbs, 430 | find_0(pb => { return pb._case(...targets); }), 431 | pb => pb._body(...targets))); 432 | } 433 | 434 | function _case(f) { 435 | cbs.push({ _case: typeof f == 'function' ? pipe(...arguments) : isMatch_0(f) }); 436 | return _body; 437 | } 438 | _case.case = _case; 439 | 440 | function _body() { 441 | cbs[cbs.length-1]._body = pipe(...arguments); 442 | return _case; 443 | } 444 | 445 | _case.else = function() { 446 | _case(_=> true) (...arguments); 447 | return targets ? evl() : (...targets2) => ((targets = targets2), evl()); 448 | }; 449 | 450 | return _case; 451 | } 452 | 453 | function match(..._) { 454 | return baseMatch(_); 455 | } 456 | 457 | match.case = (..._) => baseMatch(null).case(..._); 458 | 459 | /* harmony default export */ var match_0 = (match); 460 | // CONCATENATED MODULE: ./stopIf.js 461 | 462 | 463 | 464 | function stopIf(f, stopVal) { 465 | return match_0.case(f)(arguments.length == 2 ? _ => stop(stopVal) : stop).else(a => a); 466 | } 467 | // CONCATENATED MODULE: ./object.js 468 | 469 | 470 | function object_object(iter) { 471 | return reduce((obj, [k, v]) => (obj[k] = v, obj), {}, iter); 472 | } 473 | // CONCATENATED MODULE: ./basePick.js 474 | 475 | 476 | 477 | 478 | function basePick(filter, ks, obj) { 479 | return go( 480 | obj, 481 | entriesLazy, 482 | filter(([k]) => ks.includes(k)), 483 | object_object); 484 | } 485 | 486 | /* harmony default export */ var basePick_0 = (basePick); 487 | // CONCATENATED MODULE: ./omit.js 488 | 489 | 490 | 491 | 492 | /* harmony default export */ var omit_0 = (curry(function omit(ks, obj) { 493 | return basePick_0(Lazy_rejectLazy, ks, obj); 494 | })); 495 | // CONCATENATED MODULE: ./groupBy.js 496 | 497 | 498 | 499 | function pushSel(parent, k, v) { 500 | (parent[k] || (parent[k] = [])).push(v); 501 | return parent; 502 | } 503 | 504 | /* harmony default export */ var groupBy_0 = (curry(function groupBy(f, iter) { 505 | return reduce((group, a) => pushSel(group, f(a), a), {}, iter); 506 | })); 507 | // CONCATENATED MODULE: ./tap.js 508 | 509 | 510 | 511 | 512 | function tap(f, ...fs) { 513 | return (a, ...as) => go1(reduce(call, f(a, ...as), fs), _ => a); 514 | } 515 | // CONCATENATED MODULE: ./pipeS.js 516 | 517 | 518 | 519 | function pipeS(f, ...fs) { 520 | return (...as) => reduceS(call, f(...as), fs); 521 | } 522 | // CONCATENATED MODULE: ./isString.js 523 | function isString(a) { 524 | return typeof a == 'string'; 525 | } 526 | // CONCATENATED MODULE: ./maxBy.js 527 | 528 | 529 | 530 | /* harmony default export */ var maxBy_0 = (curry(function maxBy(f, iter) { 531 | return reduce((a, b) => f(a) >= f(b) ? a : b, iter); 532 | })); 533 | // CONCATENATED MODULE: ./max.js 534 | 535 | 536 | function max(iter) { 537 | return maxBy_0(a => a, iter); 538 | } 539 | // CONCATENATED MODULE: ./Lazy/mapLazy.js 540 | 541 | 542 | 543 | 544 | /* harmony default export */ var Lazy_mapLazy = (curry(function *mapLazy(f, iter) { 545 | for (const a of safety(iter)) yield go1(a, f); 546 | })); 547 | // CONCATENATED MODULE: ./map.js 548 | 549 | 550 | 551 | 552 | /* harmony default export */ var map_0 = (curry(function map(f, iter) { 553 | return takeAll(Lazy_mapLazy(f, iter)); 554 | })); 555 | // CONCATENATED MODULE: ./pluck.js 556 | 557 | 558 | 559 | /* harmony default export */ var pluck_0 = (curry(function pluck(k, iter) { 560 | return map_0(a => a[k], iter); 561 | })); 562 | // CONCATENATED MODULE: ./countBy.js 563 | 564 | 565 | 566 | function incSel(parent, k) { 567 | parent[k] ? parent[k]++ : parent[k] = 1; 568 | return parent; 569 | } 570 | 571 | /* harmony default export */ var countBy_0 = (curry(function countBy(f, iter) { 572 | return reduce((counts, a) => incSel(counts, f(a)), {}, iter); 573 | })); 574 | // CONCATENATED MODULE: ./Lazy/keysLazy.js 575 | function *keysLazy(obj) { 576 | for (const k in obj) yield k; 577 | }; 578 | // CONCATENATED MODULE: ./keys.js 579 | 580 | 581 | 582 | function keys(a) { 583 | return takeAll(keysLazy(a)); 584 | } 585 | // CONCATENATED MODULE: ./isUndefined.js 586 | /* harmony default export */ var isUndefined = (a => a === undefined); 587 | // CONCATENATED MODULE: ./constant.js 588 | function constant(a) { 589 | return _ => a; 590 | } 591 | // CONCATENATED MODULE: ./isIterable.js 592 | function isIterable(a) { 593 | return a != null && !!a[Symbol.iterator]; 594 | } 595 | // CONCATENATED MODULE: ./last.js 596 | function last(arr) { 597 | return arr[arr.length - 1]; 598 | } 599 | // CONCATENATED MODULE: ./uniqueBy.js 600 | 601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | const uniqueBy_uniqueBy = curry(function uniqueBy(f, iter) { 612 | const s = new Set(); 613 | const isObj = !isIterable(iter); 614 | return go( 615 | iter, 616 | isObj ? entriesLazy : identity, 617 | Lazy_filterLazy(pipe( 618 | isObj ? last : identity, 619 | f, 620 | b => s.has(b) ? false : s.add(b))), 621 | isObj ? object_object : takeAll); 622 | }); 623 | 624 | /* harmony default export */ var uniqueBy_0 = (uniqueBy_uniqueBy); 625 | // CONCATENATED MODULE: ./unique.js 626 | 627 | 628 | function unique(iter) { 629 | return uniqueBy_0(a => a, iter); 630 | } 631 | // CONCATENATED MODULE: ./indexBy.js 632 | 633 | 634 | 635 | /* harmony default export */ var indexBy_0 = (curry(function indexBy(f, iter) { 636 | return reduce((obj, a) => (obj[f(a)] = a, obj), {}, iter); 637 | })); 638 | // CONCATENATED MODULE: ./min.js 639 | 640 | 641 | function min(iter) { 642 | return minBy_0(a => a, iter); 643 | } 644 | // CONCATENATED MODULE: ./noop.js 645 | function noop() {}; 646 | // CONCATENATED MODULE: ./log.js 647 | const { log } = console; 648 | 649 | /* harmony default export */ var log_0 = (log); 650 | // CONCATENATED MODULE: ./hi.js 651 | 652 | 653 | 654 | const hi_f = tap(log_0); 655 | 656 | function hi(..._) { return hi_f(..._); } 657 | // CONCATENATED MODULE: ./baseExtend.js 658 | 659 | 660 | 661 | 662 | function baseExtend(set, obj, objs) { 663 | const type = typeof obj; 664 | obj && 665 | (type == 'object' || type == 'function') && 666 | reduce(reduce(set), obj, Lazy_mapLazy(entriesLazy, objs)); 667 | return obj; 668 | } 669 | // CONCATENATED MODULE: ./extend.js 670 | 671 | 672 | const setter = (obj, [k, v]) => (obj[k] = v, obj); 673 | 674 | function extend(obj, ...objs) { 675 | return baseExtend(setter, obj, objs); 676 | } 677 | // CONCATENATED MODULE: ./takeWhile.js 678 | 679 | 680 | 681 | 682 | 683 | /* harmony default export */ var takeWhile_0 = (curry(function takeWhile(f, iter) { 684 | let res = []; 685 | iter = toIter(iter); 686 | return function recur() { 687 | let cur; 688 | while (!(cur = iter.next()).done) { 689 | const a = cur.value; 690 | const b = go1(a, a => f(a, res)); 691 | if (!b) return res; 692 | if (b instanceof Promise) { 693 | return b 694 | .then(async b => b ? (res.push(await a), recur()) : res) 695 | .catch(e => e == nop_0 ? recur() : Promise.reject(e)); 696 | } 697 | res.push(a); 698 | } 699 | return res; 700 | } (); 701 | })); 702 | // CONCATENATED MODULE: ./Lazy/mapEntriesLazy.js 703 | 704 | 705 | 706 | 707 | /* harmony default export */ var Lazy_mapEntriesLazy = (curry(function *mapEntriesLazy(f, iter) { 708 | for (const [k, a] of safety(iter)) yield go1(go1(a, f), b => [k, b]); 709 | })); 710 | // CONCATENATED MODULE: ./mapEntries.js 711 | 712 | 713 | 714 | 715 | /* harmony default export */ var mapEntries_0 = (curry(function mapEntries(f, iter) { 716 | return takeAll(Lazy_mapEntriesLazy(f, iter)); 717 | })); 718 | // CONCATENATED MODULE: ./negate.js 719 | 720 | 721 | 722 | function negate(f) { 723 | return (..._) => go1(f(..._), not); 724 | } 725 | // CONCATENATED MODULE: ./some.js 726 | 727 | 728 | 729 | 730 | 731 | /* harmony default export */ var some_0 = (curry(function some(f, iter) { 732 | return go1(take1_0(Lazy_filterLazy(f, iter)), ({length}) => length == 1); 733 | })); 734 | // CONCATENATED MODULE: ./Lazy/flatLazy.js 735 | 736 | 737 | 738 | 739 | 740 | function flatLazy(iter, depth = 1) { 741 | const iterStack = [toIter(iter)]; 742 | return { 743 | next: function recur() { 744 | const iter = last(iterStack); 745 | if (!iter) return { done: true }; 746 | const cur = iter.next(); 747 | if (cur.done) { 748 | iterStack.pop(); 749 | return recur(); 750 | } else if (iterStack.length <= depth && isIterable(cur.value) && typeof cur.value != 'string') { 751 | iterStack.push(cur.value[Symbol.iterator]()); 752 | return recur(); 753 | } else if (cur.value instanceof Promise) { 754 | return { 755 | value: cur.value.then(value => { 756 | if (iterStack.length > depth || !isIterable(value) || typeof value == 'string') return value; 757 | const iter = value[Symbol.iterator](), cur = iter.next(); 758 | return cur.done ? Promise.reject(nop_0) : (iterStack.push(iter), cur.value); 759 | }), 760 | done: false 761 | }; 762 | } else { 763 | return cur; 764 | } 765 | }, 766 | [Symbol.iterator]() { return this; } 767 | }; 768 | } 769 | // CONCATENATED MODULE: ./Lazy/deepFlatLazy.js 770 | 771 | 772 | function deepFlatLazy(iter) { 773 | return flatLazy(iter, Infinity); 774 | } 775 | // CONCATENATED MODULE: ./deepFlat.js 776 | 777 | 778 | 779 | function deepFlat(iter) { 780 | return takeAll(deepFlatLazy(iter)); 781 | } 782 | // CONCATENATED MODULE: ./flat.js 783 | 784 | 785 | 786 | function flat(iter) { 787 | return takeAll(flatLazy(iter)); 788 | } 789 | // CONCATENATED MODULE: ./findWhere.js 790 | 791 | 792 | 793 | 794 | /* harmony default export */ var findWhere_0 = (curry(function findWhere(w, iter) { 795 | return find_0(isMatch_0(w), iter); 796 | })); 797 | // CONCATENATED MODULE: ./baseSel.js 798 | 799 | 800 | 801 | 802 | 803 | /* harmony default export */ var baseSel = (sep => curry(function sel(selector, acc) { 804 | return ( 805 | !selector ? 806 | acc 807 | : 808 | isArray_0(selector) ? 809 | reduce((acc, selector) => sel(selector, acc), acc, selector) 810 | : 811 | typeof selector == 'object' || typeof selector == 'function' ? 812 | findWhere_0(selector, acc) 813 | : 814 | reduce( 815 | (acc, key, s = key[0]) => 816 | !acc ? acc : 817 | s == '#' ? findWhere_0({ id: key.substr(1) }, acc) : 818 | s == '[' || s == '{' ? findWhere_0(JSON.parse(key), acc) : 819 | acc[key], 820 | acc, 821 | selector.split(sep)) 822 | ); 823 | })); 824 | // CONCATENATED MODULE: ./sortBy.js 825 | 826 | 827 | 828 | /* harmony default export */ var sortBy_0 = (curry(function sortBy(f, arr) { 829 | return baseSortBy(-1, 1, f, arr); 830 | })); 831 | // CONCATENATED MODULE: ./each.js 832 | 833 | 834 | 835 | 836 | /* harmony default export */ var each_0 = (curry(function each(f, iter) { 837 | return go1(reduce((_, a) => f(a), null, iter), _ => iter); 838 | })); 839 | // CONCATENATED MODULE: ./entries.js 840 | 841 | 842 | 843 | function entries_entries(a) { 844 | return takeAll(entriesLazy(a)); 845 | } 846 | // CONCATENATED MODULE: ./filter.js 847 | 848 | 849 | 850 | 851 | /* harmony default export */ var filter_0 = (curry(function filter(f, iter) { 852 | return takeAll(Lazy_filterLazy(f, iter)); 853 | })); 854 | // CONCATENATED MODULE: ./sort.js 855 | 856 | 857 | function sort_sort(arr) { 858 | return sortBy_0(a => a, arr); 859 | } 860 | // CONCATENATED MODULE: ./isFunction.js 861 | function isFunction(a) { 862 | return typeof a == 'function'; 863 | } 864 | // CONCATENATED MODULE: ./sel.js 865 | 866 | 867 | /* harmony default export */ var sel_0 = (baseSel('.')); 868 | // CONCATENATED MODULE: ./has.js 869 | 870 | 871 | /* harmony default export */ var has = (curry(function has(k, obj) { 872 | return !!(obj && obj.hasOwnProperty(k)); 873 | })); 874 | // CONCATENATED MODULE: ./flatMap.js 875 | 876 | 877 | 878 | 879 | /* harmony default export */ var flatMap_0 = (curry(function flatMap(f, iter) { 880 | return flat(map_0(f, iter)); 881 | })); 882 | // CONCATENATED MODULE: ./string.js 883 | 884 | 885 | 886 | const sadd = (a, b) => `${a}${b}`; 887 | 888 | function string(iter) { 889 | return reduce(sadd, iter); 890 | } 891 | // CONCATENATED MODULE: ./strMap.js 892 | 893 | 894 | 895 | 896 | /* harmony default export */ var strMap_0 = (curry(function strMap(f, iter) { 897 | return string(Lazy_mapLazy(f, iter)); 898 | })); 899 | // CONCATENATED MODULE: ./reject.js 900 | 901 | 902 | 903 | 904 | 905 | /* harmony default export */ var reject_0 = (curry(function reject(f, iter) { 906 | return filter_0(a => go1(f(a), not), iter); 907 | })); 908 | // CONCATENATED MODULE: ./pick.js 909 | 910 | 911 | 912 | 913 | /* harmony default export */ var pick_0 = (curry(function pick(ks, obj) { 914 | return basePick_0(Lazy_filterLazy, ks, obj); 915 | })); 916 | // CONCATENATED MODULE: ./Lazy/dropLazy.js 917 | 918 | 919 | 920 | 921 | /* harmony default export */ var Lazy_dropLazy = (curry(function *dropLazy(l, iter) { 922 | if (l < 1) return yield *safety(iter); 923 | for (const a of safety(iter)) { 924 | if (a instanceof Promise) yield a.then(a => l ? (l--, Promise.reject(nop_0)) : a); 925 | else if (l) { l--; continue; } 926 | else yield a; 927 | } 928 | })); 929 | // CONCATENATED MODULE: ./drop.js 930 | 931 | 932 | 933 | 934 | /* harmony default export */ var drop_0 = (curry(function drop(l, iter) { 935 | return takeAll(Lazy_dropLazy(l, iter)); 936 | })); 937 | // CONCATENATED MODULE: ./tail.js 938 | 939 | 940 | function tail(iter) { 941 | return drop_0(1, iter); 942 | } 943 | // CONCATENATED MODULE: ./takeUntil.js 944 | 945 | 946 | 947 | 948 | 949 | const takeUntil_takeUntil = curry(function takeUntil(f, iter) { 950 | let res = []; 951 | iter = toIter(iter); 952 | return function recur() { 953 | let cur; 954 | while (!(cur = iter.next()).done) { 955 | const a = cur.value; 956 | const b = go1(a, a => (res.push(a), f(a, res))); 957 | if (b instanceof Promise) 958 | return b.then(b => b ? res : recur()).catch(e => e == nop_0 ? recur() : Promise.reject(e)); 959 | if (b) break; 960 | } 961 | return res; 962 | } (); 963 | }); 964 | 965 | /* harmony default export */ var takeUntil_0 = (takeUntil_takeUntil); 966 | // CONCATENATED MODULE: ./defaults.js 967 | 968 | 969 | 970 | const defaults_setter = (obj, [k, v]) => { 971 | return (has(k, obj) || (obj[k] = v, obj), obj); 972 | }; 973 | 974 | function defaults(obj, ...objs) { 975 | return baseExtend(defaults_setter, obj, objs); 976 | } 977 | 978 | /* harmony default export */ var defaults_0 = (defaults); 979 | // CONCATENATED MODULE: ./baseCalls.js 980 | 981 | 982 | 983 | 984 | const baseCalls = (map, object) => function calls(fs, ...args) { 985 | return isIterable(fs) ? 986 | map(f => f(...args), fs) : 987 | object(Lazy_mapEntriesLazy(f => f(...args), entriesLazy(fs))); 988 | }; 989 | 990 | /* harmony default export */ var baseCalls_0 = (baseCalls); 991 | // CONCATENATED MODULE: ./calls.js 992 | 993 | 994 | 995 | 996 | /* harmony default export */ var calls_0 = (baseCalls_0(map_0, object_object)); 997 | // CONCATENATED MODULE: ./delay.js 998 | 999 | 1000 | /* harmony default export */ var delay = (curry(function delay(time, a) { 1001 | return new Promise(resolve => setTimeout(() => resolve(a), time)); 1002 | })); 1003 | // CONCATENATED MODULE: ./mapObject.js 1004 | 1005 | 1006 | 1007 | 1008 | 1009 | /* harmony default export */ var mapObject_0 = (curry(function mapObject(f, obj) { 1010 | return object_object(Lazy_mapEntriesLazy(f, entriesLazy(obj))); 1011 | })); 1012 | // CONCATENATED MODULE: ./promiseAllObject.js 1013 | 1014 | 1015 | 1016 | function promiseAllObject(obj) { 1017 | return mapObject_0(identity, obj); 1018 | } 1019 | // CONCATENATED MODULE: ./promiseAllEntries.js 1020 | 1021 | 1022 | 1023 | function promiseAllEntries(entries) { 1024 | return mapEntries_0(identity, entries); 1025 | } 1026 | // CONCATENATED MODULE: ./Lazy/rangeLazy.js 1027 | function *rangeLazy(start = 0, stop = start, step = 1) { 1028 | if (arguments.length == 1) start = 0; 1029 | while (start < stop) { 1030 | yield start; 1031 | start += step; 1032 | } 1033 | } 1034 | // CONCATENATED MODULE: ./range.js 1035 | 1036 | 1037 | 1038 | function range(..._) { 1039 | return takeAll(rangeLazy(..._)); 1040 | } 1041 | // CONCATENATED MODULE: ./dropRight.js 1042 | 1043 | 1044 | 1045 | 1046 | 1047 | /* harmony default export */ var dropRight = (curry(function drop(l, iter) { 1048 | return go1(takeAll(iter), arr => take_0(arr.length - l, arr)); 1049 | })); 1050 | // CONCATENATED MODULE: ./Lazy/flatMapLazy.js 1051 | 1052 | 1053 | 1054 | 1055 | /* harmony default export */ var Lazy_flatMapLazy = (curry(function flatMapLazy(f, iter) { 1056 | return flatLazy(Lazy_mapLazy(f, iter)); 1057 | })); 1058 | // CONCATENATED MODULE: ./Lazy/headTailLazy.js 1059 | 1060 | 1061 | 1062 | 1063 | function headTailLazy(iter) { 1064 | return go1(take_0(1, iter = toIter(iter)), ([head]) => [head, iter]); 1065 | } 1066 | // CONCATENATED MODULE: ./Lazy/indexValuesLazy.js 1067 | 1068 | 1069 | function *indexValuesLazy(iter) { 1070 | let i = -1; 1071 | for (const a of safety(iter)) yield [++i, a]; 1072 | }; 1073 | // CONCATENATED MODULE: ./Lazy/reverseLazy.js 1074 | function *reverseLazy(arr) { 1075 | var l = arr.length; 1076 | while (l--) yield arr[l]; 1077 | } 1078 | // CONCATENATED MODULE: ./Lazy/takeLazy.js 1079 | 1080 | 1081 | 1082 | /* harmony default export */ var Lazy_takeLazy = (curry(function *takeLazy(l, iter) { 1083 | if (l < 1) return; 1084 | for (const a of safety(iter)) { 1085 | if (a instanceof Promise) yield a.then(a => (--l, a)); 1086 | else yield (--l, a); 1087 | if (!l) break; 1088 | } 1089 | })); 1090 | // CONCATENATED MODULE: ./Lazy/takeWhileLazy.js 1091 | 1092 | 1093 | 1094 | 1095 | 1096 | /* harmony default export */ var Lazy_takeWhileLazy = (curry(function *takeWhileLazy(f, iter) { 1097 | let ok = false; 1098 | for (const a of safety(iter)) { 1099 | ok = go1(a, f); 1100 | if (ok instanceof Promise) yield ok.then(_ok => (ok = _ok) ? a : Promise.reject(nop_0)); 1101 | else if (ok) yield a; 1102 | if (!ok) break; 1103 | } 1104 | })); 1105 | // CONCATENATED MODULE: ./Lazy/takeUntilLazy.js 1106 | 1107 | 1108 | 1109 | 1110 | /* harmony default export */ var Lazy_takeUntilLazy = (curry(function *takeUntilLazy(f, iter) { 1111 | let ok = false; 1112 | for (const a of safety(iter)) { 1113 | ok = go1(a, f); 1114 | if (ok instanceof Promise) yield ok.then(_ok => ((ok = _ok), a)); 1115 | else yield a; 1116 | if (ok) break; 1117 | } 1118 | })); 1119 | // CONCATENATED MODULE: ./Lazy/intervalLazy.js 1120 | 1121 | 1122 | 1123 | 1124 | function intervalLazy(time) { 1125 | return Lazy_mapLazy(delay(time), rangeLazy(Infinity)); 1126 | } 1127 | // CONCATENATED MODULE: ./L.js 1128 | 1129 | 1130 | 1131 | 1132 | 1133 | 1134 | 1135 | 1136 | 1137 | 1138 | 1139 | 1140 | 1141 | 1142 | 1143 | 1144 | 1145 | 1146 | 1147 | 1148 | const L = { 1149 | deepFlat: deepFlatLazy, 1150 | deep_flat: deepFlatLazy, 1151 | deepFlatten: deepFlatLazy, 1152 | deep_flatten: deepFlatLazy, 1153 | entries: entriesLazy, 1154 | entriesMap: Lazy_mapEntriesLazy, 1155 | entries_map: Lazy_mapEntriesLazy, 1156 | mapEntries: Lazy_mapEntriesLazy, 1157 | map_entries: Lazy_mapEntriesLazy, 1158 | filter: Lazy_filterLazy, 1159 | flat: flatLazy, 1160 | flatMap: Lazy_flatMapLazy, 1161 | flat_map: Lazy_flatMapLazy, 1162 | headTail: headTailLazy, 1163 | indexValues: indexValuesLazy, 1164 | index_values: indexValuesLazy, 1165 | keys: keysLazy, 1166 | map: Lazy_mapLazy, 1167 | range: rangeLazy, 1168 | reject: Lazy_rejectLazy, 1169 | reverse: reverseLazy, 1170 | values: valuesLazy, 1171 | take: Lazy_takeLazy, 1172 | takeWhile: Lazy_takeWhileLazy, 1173 | take_while: Lazy_takeWhileLazy, 1174 | takeUntil: Lazy_takeUntilLazy, 1175 | take_until: Lazy_takeUntilLazy, 1176 | interval: intervalLazy, 1177 | drop: Lazy_dropLazy 1178 | }; 1179 | 1180 | 1181 | // CONCATENATED MODULE: ./Concurrency/catchNoop.js 1182 | function catchNoop(arr) { 1183 | arr.forEach(a => a instanceof Promise ? a.catch(function() {}) : a); 1184 | return arr; 1185 | } 1186 | 1187 | /* harmony default export */ var Concurrency_catchNoop = (catchNoop); 1188 | // CONCATENATED MODULE: ./Concurrency/dropC.js 1189 | 1190 | 1191 | 1192 | 1193 | /* harmony default export */ var Concurrency_dropC = (curry(function dropC(l, iter) { 1194 | return drop_0(l, Concurrency_catchNoop([...iter])); 1195 | })); 1196 | // CONCATENATED MODULE: ./Concurrency/tailC.js 1197 | 1198 | 1199 | function tailC(iter) { 1200 | return Concurrency_dropC(1, iter); 1201 | } 1202 | // CONCATENATED MODULE: ./Concurrency/reduceC.js 1203 | 1204 | 1205 | 1206 | 1207 | /* harmony default export */ var Concurrency_reduceC = (curry(function reduceC(f, acc, iter) { 1208 | return arguments.length == 2 ? 1209 | reduce(f, Concurrency_catchNoop([...acc])) : 1210 | reduce(f, acc, Concurrency_catchNoop([...iter])); 1211 | })); 1212 | // CONCATENATED MODULE: ./Concurrency/takeC.js 1213 | 1214 | 1215 | 1216 | 1217 | /* harmony default export */ var Concurrency_takeC = (curry(function takeC(l, iter) { 1218 | return take_0(l, Concurrency_catchNoop([...iter])); 1219 | })); 1220 | // CONCATENATED MODULE: ./Concurrency/takeAllC.js 1221 | 1222 | 1223 | /* harmony default export */ var takeAllC = (Concurrency_takeC(Infinity)); 1224 | // CONCATENATED MODULE: ./Concurrency/mapEntriesC.js 1225 | 1226 | 1227 | 1228 | 1229 | /* harmony default export */ var Concurrency_mapEntriesC = (curry(async function mapEntriesC(f, iter) { 1230 | return takeAllC(Lazy_mapEntriesLazy(f, iter)); 1231 | })); 1232 | // CONCATENATED MODULE: ./Concurrency/headC.js 1233 | 1234 | 1235 | 1236 | function headC(iter) { 1237 | return go1(Concurrency_takeC(1, iter), ([h]) => h); 1238 | } 1239 | // CONCATENATED MODULE: ./Concurrency/findC.js 1240 | 1241 | 1242 | 1243 | 1244 | /* harmony default export */ var Concurrency_findC = (curry(function findC(f, iter) { 1245 | return headC(Lazy_filterLazy(f, iter)); 1246 | })); 1247 | // CONCATENATED MODULE: ./Concurrency/mapC.js 1248 | 1249 | 1250 | 1251 | 1252 | /* harmony default export */ var Concurrency_mapC = (curry(function mapC(f, iter) { 1253 | return takeAllC(Lazy_mapLazy(f, iter)); 1254 | })); 1255 | // CONCATENATED MODULE: ./Concurrency/take1C.js 1256 | 1257 | 1258 | /* harmony default export */ var take1C = (Concurrency_takeC(1)); 1259 | // CONCATENATED MODULE: ./Concurrency/everyC.js 1260 | 1261 | 1262 | 1263 | 1264 | 1265 | /* harmony default export */ var Concurrency_everyC = (curry(function everyC(f, iter) { 1266 | return go1(take1C(Lazy_rejectLazy(f, iter)), ({length}) => length == 0); 1267 | }));; 1268 | // CONCATENATED MODULE: ./Concurrency/filterC.js 1269 | 1270 | 1271 | 1272 | 1273 | /* harmony default export */ var Concurrency_filterC = (curry(function filterC(f, iter) { 1274 | return takeAllC(Lazy_filterLazy(f, iter)); 1275 | })); 1276 | // CONCATENATED MODULE: ./Concurrency/objectC.js 1277 | 1278 | 1279 | function objectC(iter) { 1280 | return Concurrency_reduceC((obj, [k, v]) => (obj[k] = v, obj), {}, iter); 1281 | } 1282 | // CONCATENATED MODULE: ./Concurrency/callsC.js 1283 | 1284 | 1285 | 1286 | 1287 | /* harmony default export */ var callsC = (baseCalls_0(Concurrency_mapC, objectC)); 1288 | // CONCATENATED MODULE: ./Concurrency/someC.js 1289 | 1290 | 1291 | 1292 | 1293 | 1294 | /* harmony default export */ var Concurrency_someC = (curry(function someC(f, iter) { 1295 | return go1(take1C(Lazy_filterLazy(f, iter)), ({length}) => length == 1); 1296 | })); 1297 | // CONCATENATED MODULE: ./C.js 1298 | 1299 | 1300 | 1301 | 1302 | 1303 | 1304 | 1305 | 1306 | 1307 | 1308 | 1309 | 1310 | 1311 | 1312 | 1313 | const C = { 1314 | tail: tailC, 1315 | reduce: Concurrency_reduceC, 1316 | take: Concurrency_takeC, 1317 | mapEntries: Concurrency_mapEntriesC, 1318 | map_entries: Concurrency_mapEntriesC, 1319 | entriesMap: Concurrency_mapEntriesC, 1320 | entries_map: Concurrency_mapEntriesC, 1321 | find: Concurrency_findC, 1322 | map: Concurrency_mapC, 1323 | every: Concurrency_everyC, 1324 | filter: Concurrency_filterC, 1325 | takeAll: takeAllC, 1326 | take_all: takeAllC, 1327 | head: headC, 1328 | take1: take1C, 1329 | calls: callsC, 1330 | some: Concurrency_someC, 1331 | drop: Concurrency_dropC 1332 | }; 1333 | 1334 | 1335 | // CONCATENATED MODULE: ./fx-browser.js 1336 | 1337 | 1338 | 1339 | 1340 | 1341 | 1342 | 1343 | 1344 | 1345 | 1346 | 1347 | 1348 | 1349 | 1350 | 1351 | 1352 | 1353 | 1354 | 1355 | 1356 | 1357 | 1358 | 1359 | 1360 | 1361 | 1362 | 1363 | 1364 | 1365 | 1366 | 1367 | 1368 | 1369 | 1370 | 1371 | 1372 | 1373 | 1374 | 1375 | 1376 | 1377 | 1378 | 1379 | 1380 | 1381 | 1382 | 1383 | 1384 | 1385 | 1386 | 1387 | 1388 | 1389 | 1390 | 1391 | 1392 | 1393 | 1394 | 1395 | 1396 | 1397 | 1398 | 1399 | 1400 | 1401 | 1402 | 1403 | 1404 | 1405 | 1406 | 1407 | 1408 | 1409 | 1410 | 1411 | 1412 | 1413 | 1414 | 1415 | 1416 | 1417 | 1418 | 1419 | 1420 | 1421 | 1422 | 1423 | 1424 | 1425 | window.fx = window._ = {}; 1426 | window.fx.L = window.L = L_namespaceObject.L; 1427 | window.fx.C = window.C = C_namespaceObject.C; 1428 | 1429 | _.minBy = _.min_by = minBy_0; 1430 | _.sortDesc = _.sort_desc = sort; 1431 | _.go = go; 1432 | _.goS = goS; 1433 | _.identity = identity; 1434 | _.reduce = reduce; 1435 | _.reduceS = reduceS; 1436 | _.stop = stop; 1437 | _.stopIf = _.stop_if = stopIf; 1438 | _.take = take_0; 1439 | _.omit = omit_0; 1440 | _.values = values; 1441 | _.groupBy = _.group_by = groupBy_0; 1442 | _.tap = tap; 1443 | _.pipe = pipe; 1444 | _.pipeS = pipeS; 1445 | _.isString = _.is_string = isString; 1446 | _.max = max; 1447 | _.pluck = pluck_0; 1448 | _.takeAll = _.take_all = takeAll; 1449 | _.countBy = _.count_by = countBy_0; 1450 | _.keys = keys; 1451 | _.isUndefined = _.is_undefined = isUndefined; 1452 | _.constant = constant; 1453 | _.unique = _.uniq = unique; 1454 | _.indexBy = _.index_by = indexBy_0; 1455 | _.min = min; 1456 | _.sortByDesc = _.sort_by_desc = sortByDesc_0; 1457 | _.noop = noop; 1458 | _.hi = hi; 1459 | _.extend = extend; 1460 | _.empty = empty; 1461 | _.takeWhile = _.take_while = takeWhile_0; 1462 | _.isMatch = _.is_match = isMatch_0; 1463 | _.mapEntries = _.map_entries = _.entriesMap = _.entries_map = mapEntries_0; 1464 | _.object = object_object; 1465 | _.negate = negate; 1466 | _.nop = nop_0; 1467 | _.call = call; 1468 | _.some = some_0; 1469 | _.deepFlat = _.deepFlatten = _.deep_flat = _.deep_flatten = deepFlat; 1470 | _.toIter = _.to_iter = toIter; 1471 | _.maxBy = _.max_by = maxBy_0; 1472 | _.flat = _.flatten = flat; 1473 | _.baseSel = _.base_sel = baseSel; 1474 | _.sortBy = _.sort_by = sortBy_0; 1475 | _.not = not; 1476 | _.go1 = go1; 1477 | _.find = find_0; 1478 | _.isArray = _.is_array = isArray_0; 1479 | _.each = each_0; 1480 | _.entries = entries_entries; 1481 | _.filter = filter_0; 1482 | _.sort = sort_sort; 1483 | _.curry = curry; 1484 | _.isFunction = _.is_function = isFunction; 1485 | _.sel = sel_0; 1486 | _.match = match_0; 1487 | _.map = map_0; 1488 | _.head = head; 1489 | _.every = every_0; 1490 | _.has = has; 1491 | _.isIterable = _.is_iterable = isIterable; 1492 | _.uniqueBy = _.unique_by = uniqueBy_0; 1493 | _.flatMap = _.flat_map = flatMap_0; 1494 | _.string = string; 1495 | _.strMap = _.str_map = _.scat = strMap_0; 1496 | _.findWhere = _.find_where = findWhere_0; 1497 | _.reject = reject_0; 1498 | _.pick = pick_0; 1499 | _.last = last; 1500 | _.take1 = take1_0; 1501 | _.tail = tail; 1502 | _.log = log_0; 1503 | _.takeUntil = _.take_until = takeUntil_0; 1504 | _.defaults = defaults_0; 1505 | _.calls = calls_0; 1506 | _.delay = delay; 1507 | _.safety = safety; 1508 | _.mapObject = _.map_object = mapObject_0; 1509 | _.promiseAllObject = _.promise_all_object = promiseAllObject; 1510 | _.promiseAllEntries = _.promise_all_entries = promiseAllEntries; 1511 | _.isStop = _.is_stop = isStop; 1512 | _.range = range; 1513 | _.drop = drop_0; 1514 | _.dropRight = _.drop_right = dropRight; 1515 | 1516 | /***/ }) 1517 | /******/ ]); 1518 | //# sourceMappingURL=fx.js.map --------------------------------------------------------------------------------