Add examples

Author: tshemsedinov

JavaScript/1-asyncify.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// Synchronous function to callback-last
+
+const asyncify = fn => (...args) => {
+  const callback = args.pop();
+  setTimeout(() => {
+    try {
+      const result = fn(...args);
+      if (result instanceof Error) callback(result);
+      else callback(null, result);
+    } catch (error) {
+      callback(error);
+    }
+  }, 0);
+};
+
+// Usage
+
+const twice = x => x * 2;
+const twiceAsync = asyncify(twice);
+
+const half = x => x / 2;
+const halfAsync = asyncify(half);
+
+const result = half(twice(100));
+console.dir({ sync: result });
+
+twiceAsync(100, (e, value) => {
+  halfAsync(value, (e, result) => {
+    console.dir({ asyncified: result });
+  });
+});

JavaScript/2-promisify.js

@@ -0,0 +1,36 @@
+'use strict';
+
+// Callback-last function to Promise-returning
+
+const promisify = fn => (...args) => new Promise(
+  (resolve, reject) => {
+    fn(...args, (err, data) => {
+      if (err) reject(err);
+      else resolve(data);
+    });
+  }
+);
+
+// Usage
+
+const twiceCallback = (x, callback) => {
+  callback(null, x * 2);
+};
+const twicePromise = promisify(twiceCallback);
+
+const halfCallback = (x, callback) => {
+  callback(null, x / 2);
+};
+const halfPromise = promisify(halfCallback);
+
+twiceCallback(100, (e, value) => {
+  halfCallback(value, (e, result) => {
+    console.dir({ callbackLast: result });
+  });
+});
+
+twicePromise(100)
+  .then(value => halfPromise(value))
+  .then(result => {
+    console.dir({ promisified: result });
+  });

JavaScript/3-promisify-sync.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// Synchronous function to Promise-returning
+
+const promisifySync = fn => (...args) => {
+  try {
+    const result = fn(...args);
+    if (result instanceof Error) return Promise.reject(result);
+    else return Promise.resolve(result);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};
+
+// Usage
+
+const twice = x => x * 2;
+const twicePromise = promisifySync(twice);
+
+const half = x => x / 2;
+const halfPromise = promisifySync(half);
+
+const result = half(twice(100));
+console.dir({ sync: result });
+
+twicePromise(100)
+  .then(value => halfPromise(value))
+  .then(result => {
+    console.dir({ promise: result });
+  });

JavaScript/4-callbackify.js

@@ -0,0 +1,34 @@
+'use strict';
+
+// Promise-returning function callback-last / error-first
+
+const callbackify = fn => (...args) => {
+  const callback = args.pop();
+  fn(...args)
+    .then(value => {
+      callback(null, value);
+    })
+    .catch(reason => {
+      callback(reason);
+    });
+};
+
+// Usage
+
+const twicePromise = x => Promise.resolve(x * 2);
+const twiceCallback = callbackify(twicePromise);
+
+const halfPromise = x => Promise.resolve(x / 2);
+const halfCallback = callbackify(halfPromise);
+
+twicePromise(100)
+  .then(value => halfPromise(value))
+  .then(result => {
+    console.dir({ promise: result });
+  });
+
+twiceCallback(100, (e, value) => {
+  halfCallback(value, (e, result) => {
+    console.dir({ callbackLast: result });
+  });
+});

JavaScript/5-promise-to-cb.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// Convert Promise to callback-last
+
+const promiseToCallbackLast = promise => callback => {
+  promise.then(value => {
+    callback(null, value);
+  }).catch(reason => {
+    callback(reason);
+  });
+};
+
+// Usage
+
+const promise = Promise.resolve('value');
+const fnCallbackLast = promiseToCallbackLast(promise);
+
+fnCallbackLast((e, result) => {
+  console.dir({ callbackLast: result });
+});