rainder · November 22, 2017 16:50 · Nov 22, 2017 · Jul 27, 2017 · Jan 25, 2016 · Jan 25, 2016
diff --git a/JS::DeferredFnStack.js b/JS::DeferredFnStack.js
@@ -3,12 +3,12 @@
 function DeferredFnStack(fn) {
   let stack = Promise.resolve();
 
-  return () => {
+  return (...args) => {
     const dfd = defer();
 
     stack = stack
       .catch(() => null)
-      .then(() => fn().then(dfd.resolve, dfd.reject));
+      .then(() => fn(...args).then(dfd.resolve, dfd.reject));
 
     return dfd.promise;
   };

diff --git a/JS::DeferredFnStack.js b/JS::DeferredFnStack.js
@@ -1,30 +1,42 @@
 'use strict';
-const Q = require('q')
 
 function DeferredFnStack(fn) {
-  let stack = Q.when();
+  let stack = Promise.resolve();
+
+  return () => {
+    const dfd = defer();
+
+    stack = stack
+      .catch(() => null)
+      .then(() => fn().then(dfd.resolve, dfd.reject));
 
-  return function () {
-    const dfd = Q.defer();
-    stack = stack.fin(() => Q.when(fn()).then(dfd.resolve, dfd.reject));
     return dfd.promise;
   };
+
+  /**
+   *
+   * @returns {{}}
+   */
+  function defer() {
+    const dfd = {};
+
+    dfd.promise = new Promise((resolve, reject) => {
+      dfd.resolve = resolve;
+      dfd.reject = reject;
+    });
+
+    return dfd;
+  }
 }
 
 /**
  * USAGE
  */
 
-function asyncPromise(value) {
-  return new Promise(function (resolve) {
-    setTimeout(() => resolve(value), 500);
+const fn = DeferredFnStack(() => {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve('hi'), 1000);
   });
-}
-
-const fn = DeferredFnStack(function () {
-  return Q.resolve('Hello World!')
-    .then(asyncPromise)
-    .then(asyncPromise)
 });
 
 fn().then((value) => console.log(value));
@@ -33,4 +45,4 @@ fn().then((value) => console.log(value));
 
 /*
  Outputs 3 times 'Hello World!' with 1000ms interval
- */
+ */
diff --git a/JS::DeferredFnStack.js b/JS::DeferredFnStack.js
@@ -4,7 +4,7 @@ const Q = require('q')
 function DeferredFnStack(fn) {
   let stack = Q.when();
 
-  return () => {
+  return function () {
     const dfd = Q.defer();
     stack = stack.fin(() => Q.when(fn()).then(dfd.resolve, dfd.reject));
     return dfd.promise;
@@ -16,12 +16,9 @@ function DeferredFnStack(fn) {
  */
 
 function asyncPromise(value) {
-  const dfd = Q.defer();
-
-  const resolve = () => dfd.resolve(value)
-  setTimeout(resolve, 500)
-
-  return dfd.promise
+  return new Promise(function (resolve) {
+    setTimeout(() => resolve(value), 500);
+  });
 }
 
 const fn = DeferredFnStack(function () {

diff --git a/JS::DeferredFnStack → JS::DeferredFnStack.js b/JS::DeferredFnStack → JS::DeferredFnStack.js
diff --git a/JS::DeferredFnStack b/JS::DeferredFnStack
@@ -1,38 +1,39 @@
-Q = require 'q'
+'use strict';
+const Q = require('q')
 
-DeferredFnStack = (fn) ->
-  stack = Q.when()
+function DeferredFnStack(fn) {
+  let stack = Q.when();
 
-  return ->
-    dfd = Q.defer()
-    stack = stack.fin -> Q.when(fn()).then(dfd.resolve, dfd.reject)
-    dfd.promise
+  return () => {
+    const dfd = Q.defer();
+    stack = stack.fin(() => Q.when(fn()).then(dfd.resolve, dfd.reject));
+    return dfd.promise;
+  };
+}
 
-###
-  USAGE
-###
+/**
+ * USAGE
+ */
 
-asyncPromise = (value) ->
-  dfd = Q.defer()
+function asyncPromise(value) {
+  const dfd = Q.defer();
 
-  resolve = ->
-    dfd.resolve(value)
+  const resolve = () => dfd.resolve(value)
+  setTimeout(resolve, 500)
 
-  setTimeout resolve, 500
+  return dfd.promise
+}
 
-  dfd.promise
+const fn = DeferredFnStack(function () {
+  return Q.resolve('Hello World!')
+    .then(asyncPromise)
+    .then(asyncPromise)
+});
 
+fn().then((value) => console.log(value));
+fn().then((value) => console.log(value));
+fn().then((value) => console.log(value));
 
-fn = DeferredFnStack ->
-  Q.resolve('Hello World!')
-  .then asyncPromise
-  .then asyncPromise
-
-
-fn().then (value) -> console.log value
-fn().then (value) -> console.log value
-fn().then (value) -> console.log value
-
-###
-  Outputs 3 times 'Hello World!' with 1000ms interval
-###
+/*
+ Outputs 3 times 'Hello World!' with 1000ms interval
+ */
diff --git a/DeferredFnStack → JS::DeferredFnStack b/DeferredFnStack → JS::DeferredFnStack
diff --git a/DeferredFnStack b/DeferredFnStack
@@ -7,18 +7,32 @@ DeferredFnStack = (fn) ->
     dfd = Q.defer()
     stack = stack.fin -> Q.when(fn()).then(dfd.resolve, dfd.reject)
     dfd.promise
-
-
-# USAGE
+
+###
+  USAGE
+###
+
+asyncPromise = (value) ->
+  dfd = Q.defer()
+
+  resolve = ->
+    dfd.resolve(value)
+
+  setTimeout resolve, 500
+
+  dfd.promise
+
 
 fn = DeferredFnStack ->
-  Q.when()
-  .then asyncAction1
-  .then asyncAction2
-  .then asyncAction3
-
-fn()
-fn()
-fn()
-fn()
-fn()
+  Q.resolve('Hello World!')
+  .then asyncPromise
+  .then asyncPromise
+
+
+fn().then (value) -> console.log value
+fn().then (value) -> console.log value
+fn().then (value) -> console.log value
+
+###
+  Outputs 3 times 'Hello World!' with 1000ms interval
+###
diff --git a/DeferredFnStack b/DeferredFnStack
@@ -6,4 +6,19 @@ DeferredFnStack = (fn) ->
   return ->
     dfd = Q.defer()
     stack = stack.fin -> Q.when(fn()).then(dfd.resolve, dfd.reject)
-    dfd.promise
+    dfd.promise
+
+
+# USAGE
+
+fn = DeferredFnStack ->
+  Q.when()
+  .then asyncAction1
+  .then asyncAction2
+  .then asyncAction3
+
+fn()
+fn()
+fn()
+fn()
+fn()
diff --git a/DeferredFnStack b/DeferredFnStack
@@ -1,9 +1,9 @@
 Q = require 'q'
 
-DeferredFnStack = (action) ->
+DeferredFnStack = (fn) ->
   stack = Q.when()
 
   return ->
     dfd = Q.defer()
-    stack = stack.fin -> Q.when(action()).then(dfd.resolve, dfd.reject)
+    stack = stack.fin -> Q.when(fn()).then(dfd.resolve, dfd.reject)
     dfd.promise
diff --git a/DeferredFnStack b/DeferredFnStack
@@ -1,3 +1,5 @@
+Q = require 'q'
+
 DeferredFnStack = (action) ->
   stack = Q.when()
 

diff --git a/DeferredFnStack b/DeferredFnStack
@@ -0,0 +1,7 @@
+DeferredFnStack = (action) ->
+  stack = Q.when()
+
+  return ->
+    dfd = Q.defer()
+    stack = stack.fin -> Q.when(action()).then(dfd.resolve, dfd.reject)
+    dfd.promise