Fibers

var Fiber = require('fibers');

var Future = require('fibers/future');

var Fiber = require('fibers');

function sleep(ms) {
  var fiber = Fiber.current;
  setTimeout(function() {
    fiber.run();
  }, ms);
  Fiber.yield();
}

Fiber(function() {
  console.log('wait... ' + new Date);
  sleep(1000);
  console.log('ok... ' + new Date);
}).run();
console.log('back in main');

/**
 * Creates a new fiber that executes the given function
 * @param {Function} fn - Function to execute in the fiber
 * @returns {Fiber} New fiber instance
 */
function Fiber(fn) { /* [native code] */ }

/**
 * Reference to currently executing fiber (undefined if on main stack)
 */
Fiber.current = undefined;

/**
 * Halts current fiber execution and returns control to caller
 * @param {*} param - Optional value to return to caller
 * @returns {*} Value passed to next run() call
 */
Fiber.yield = function(param) { /* [native code] */ }

/**
 * Future constructor for async operations
 */
function Future() {}

/**
 * Runs function in fiber context and returns future to its return value
 * @param {Function} fn - Function to run in fiber
 * @returns {Future} Future resolving to function's return value
 */
Future.task = function(fn) { /* ... */ }

/**
 * Wraps node-style async functions to return futures
 * @param {Function|Object} fnOrObject - Function or object to wrap
 * @param {boolean} multi - Whether callback returns multiple arguments
 * @param {string} suffix - Suffix for wrapped method names
 * @returns {Function|Object} Future-returning function or wrapped object
 */
Future.wrap = function(fnOrObject, multi, suffix) { /* ... */ }

/**
 * Fiber class for cooperative multitasking
 */
class Fiber {
  /**
   * Starts or resumes fiber execution
   * @param {*} param - Optional parameter to pass to fiber
   * @returns {*} Value passed to yield() or fiber return value
   */
  run(param) { /* [native code] */ }
  
  /**
   * Terminates running fiber and restores to original state
   * @returns {*} Return value from fiber if any
   */
  reset() { /* [native code] */ }
  
  /**
   * Causes yielding fiber's yield() to throw instead of return
   * @param {Error} exception - Exception to throw in fiber
   */
  throwInto(exception) { /* [native code] */ }
}

/**
 * Future class for Promise-like async operations
 */
class Future {
  /**
   * Returns future value (throws if not resolved)
   * @returns {*} The resolved value
   */
  get() { /* ... */ }
  
  /**
   * Resolves future with value
   * @param {*} value - Value to resolve with
   */
  return(value) { /* ... */ }
  
  /**
   * Rejects future with error
   * @param {Error} error - Error to reject with
   */
  throw(error) { /* ... */ }
  
  /**
   * Waits for future to resolve and returns value
   * @returns {*} The resolved value
   */
  wait() { /* ... */ }
  
  /**
   * Returns boolean indicating if future is resolved
   * @returns {boolean} True if resolved, false otherwise
   */
  isResolved() { /* ... */ }
  
  /**
   * Propagate only errors to another future or array of futures
   * @param {Future|Future[]} futures - Target future(s) for error propagation
   * @returns {Future} This future for chaining
   */
  proxyErrors(futures) { /* ... */ }
}