Initial commit

Author: aqrln

.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+node_modules
+npm_debug.log

catch-promise.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const getJSON = require('./get-json');
+const doMonad = require('./do-notation');
+
+const baseUrl = 'http://localhost:3000/';
+doMonad(function* () {
+  let api = yield getJSON(baseUrl);
+  for (let resource of api.resources) {
+    let data = yield getJSON(baseUrl + resource);
+    console.log(data);
+  }
+}).catch(e => {
+  console.log(e);
+});

do-maybe.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { Just, Nothing } = require('./maybe');
+const doMonad = require('./do-notation');
+
+Just(5).then(x => (
+  Just(x + 3)
+).then(x => (
+  Just(x * 4)
+)).then(console.log));
+
+doMonad(function* () {
+  let a = yield Just(5);
+  let b = yield Just(3);
+  let c = yield Just(4);
+  console.log((a + b) * c);
+});

do-notation.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = (generator) => {
+  let sequence = generator();
+  return step();
+
+  function step(value) {
+    let result = sequence.next(value);
+    if (result.done) {
+      return result.value;
+    }
+    return result.value.then(step);
+  }
+};

do-promise.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const getJSON = require('./get-json');
+const doMonad = require('./do-notation');
+
+const baseUrl = 'http://localhost:3000/';
+doMonad(function* () {
+  let api = yield getJSON(baseUrl);
+  for (let resource of api.resources) {
+    let data = yield getJSON(baseUrl + resource);
+    console.log(data);
+  }
+});

get-json.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const http = require('http');
+
+module.exports = (url) => {
+  return new Promise((resolve, reject) => {
+    http.get(url, res => {
+      let code = res.statusCode;
+      if (code !== 200) {
+        return reject(new Error(`HTTP status code ${code}`));
+      }
+
+      res.on('error', reject);
+
+      let chunks = [];
+      res.on('data', chunk => {
+        chunks.push(chunk);
+      });
+
+      res.on('end', () => {
+        let json = Buffer.concat(chunks).toString();
+        let object = null;
+
+        try {
+          object = JSON.parse(json);
+        } catch (error) {
+          return reject(error);
+        }
+
+        resolve(object);
+      });
+    });
+  });
+};

maybe-catch.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const doMonad = require('./do-notation');
+
+class Just {
+  constructor(value) {
+    this.value = value;
+  }
+
+  then(fn) {
+    let result = fn(this.value);
+    if (result instanceof Just ||
+        result === Nothing) {
+      return result;
+    } else {
+      return new Just(result);
+    }
+  }
+
+  catch() {
+    return this;
+  }
+}
+
+const Nothing = {
+  then() {
+    return Nothing;
+  },
+
+  catch(callback) {
+    callback();
+    return this;
+  }
+};
+
+doMonad(function* () {
+  let a = yield new Just(5);
+  let b = yield new Just(3);
+  let c = yield new Just(4);
+  console.log((a + b) * c);
+}).catch(() => {
+  console.log('At least one value is not present');
+});

maybe.js

@@ -0,0 +1,25 @@
+'use strict';
+
+function Just(value) {
+  return {
+    toString() {
+      return `Just ${value}`;
+    },
+
+    then(fn) {
+      return fn(value);
+    }
+  };
+}
+
+const Nothing = {
+  toString() {
+    return 'Nothing';
+  },
+
+  then() {
+    return Nothing;
+  }
+};
+
+module.exports = { Just, Nothing };

presentation.md

@@ -0,0 +1,167 @@
+Генераторы в JavaScript. Часть 1
+================================
+
+@aqrln
+
+---
+
+### Итерабельные объекты и итераторы в ES6
+
+Среди нововведений в  ES6,  помимо  новых  синтаксических  конструкций  и  типов
+данных, есть и два новых интерфейса: протокол итерабельных объектов  и  протокол
+итераторов.
+
+MDN:
+
+* [Iterable protocol](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)
+* [Iterator protocol](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols#iterator)
+
+---
+
+### Iterable Protocol
+
+```javascript
+let myIterable = {
+  ...
+
+  [Symbol.iterator]() {
+    let iterator = ...;
+    return iterator;
+  }
+
+  ...
+}
+```
+
+---
+
+### Iterator Protocol
+
+```javascript
+let iterator = {
+  ...
+
+  next() {
+    // Если ещё остались значения
+    return {
+      value: currentValue,
+      done: false
+    };
+
+    // Если значения закончились
+    return {
+      value: undefined,
+      done: true
+    }
+  }
+}
+```
+
+---
+
+### Примеры итерабельных объектов
+
+ * Array
+ * TypedArray
+ * String
+ * Buffer
+ * Map
+ * Set
+
+---
+
+### Методы коллекций, которые возвращают итераторы
+
+ * keys()
+ * values()
+ * entries()
+
+---
+
+### Некоторые функции, которые принимают итерабельные объекты
+
+ * Конструкторы новых коллекций в ES6 (Map, Set...)
+ * Array.from()
+ * Promise.all(), Promise.race()
+
+---
+
+### Синтаксические конструкции, которые работают с итерабельными объектами
+
+ * Цикл for-of
+ * Spread
+ * Destructuring assignment
+ * yield*
+
+---
+
+### Генераторы
+
+Generator function — это функция, возвращающая специальный  итератор  (generator
+object),  управляющий  её  выполнением.   Оператор  `yield`  в  теле   функции
+приостанавливает   выполнение,   метод   `next()`   итератора   —    продолжает.
+
+---
+
+Объекты-генераторы одновременно являются и итерабельными объектами, и
+итераторами:
+
+```javascript
+> function* generatorFunction() { } 
+undefined
+> let generatorObject = generatorFunction() 
+undefined
+> generatorObject.next 
+[Function: next]
+> generatorObject[Symbol.iterator]() === generatorObject 
+true
+```
+
+---
+
+### Yield
+
+Оператор `yield` служит  для  двунаправленного  обмена  данными  с  генератором.
+Значение, стоящее после ключевого слова `yield`,  становится  текущим  значением
+итератора, а в метод  `next()`  опционально  можно  передать  значение,  которое
+примет yield-выражение.
+
+---
+
+### Yield*
+
+```javascript
+yield* from iterable;
+```
+
+#### ≈
+
+```javascript
+for (let value of iterable) {
+  yield value;
+}
+```
+
+---
+
+### Yield* Expression
+
+```javascript
+function* g1() {
+  yield* [1, 2, 3];
+  return 'result';
+}
+
+let result = null;
+
+function* g2() {
+  result = yield* g1();
+}
+
+console.log([...g2()]); // [1, 2, 3]
+console.log(result);    // 'result' 
+```
+
+---
+
+# Q&A

primes.js

@@ -0,0 +1,34 @@
+'use strict';
+
+function* numbers(start) {
+  while (true) {
+    yield start++;
+  }
+}
+
+function* sieve(sequence, prime) {
+  for (let number of sequence) {
+    if (number % prime !== 0) {
+      yield number;
+    }
+  }
+}
+
+function* primes() {
+  var sequence = numbers(2);
+  while (true) {
+    let prime = sequence.next().value;
+    yield prime;
+    sequence = sieve(sequence, prime);
+  }
+}
+
+function* take(count, sequence) {
+  for (let i = 0; i < count; i++) {
+    yield sequence.next().value;
+  }
+}
+
+for (var prime of take(10, primes())) {
+  console.log(prime);
+}