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');

var Fiber = require('fibers');
 
var inc = Fiber(function(start) {
    var total = start;
    while (true) {
        total += Fiber.yield(total);
    }
});
 
for (var ii = inc.run(1); ii <= 10; ii = inc.run(1)) {
    console.log(ii);
}

var Fiber = require('fibers');
 
// Generator function. Returns a function which returns incrementing
// Fibonacci numbers with each call.
function Fibonacci() {
    // Create a new fiber which yields sequential Fibonacci numbers
    var fiber = Fiber(function() {
        Fiber.yield(0); // F(0) -> 0
        var prev = 0, curr = 1;
        while (true) {
            Fiber.yield(curr);
            var tmp = prev + curr;
            prev = curr;
            curr = tmp;
        }
    });
    // Return a bound handle to `run` on this fiber
    return fiber.run.bind(fiber);
}
 
// Initialize a new Fibonacci sequence and iterate up to 1597
var seq = Fibonacci();
for (var ii = seq(); ii <= 1597; ii = seq()) {
    console.log(ii);
}

var Fiber = require('fibers');
 
var fn = Fiber(function() {
    console.log('async work here...');
    Fiber.yield();
    console.log('still working...');
    Fiber.yield();
    console.log('just a little bit more...');
    Fiber.yield();
    throw new Error('oh crap!');
});
 
try {
    while (true) {
        fn.run();
    }
} catch(e) {
    console.log('safely caught that error!');
    console.log(e.stack);
}
console.log('done!');

var Future = require('fibers/future'), wait = Future.wait;
var fs = require('fs');
 
// This wraps existing functions assuming the last argument of the passed
// function is a callback. The new functions created immediately return a
// future and the future will resolve when the callback is called (which
// happens behind the scenes).
var readdir = Future.wrap(fs.readdir);
var stat = Future.wrap(fs.stat);
 
Fiber(function() {
    // Get a list of files in the directory
    var fileNames = readdir('.').wait();
    console.log('Found '+ fileNames.length+ ' files');
 
    // Stat each file
    var stats = [];
    for (var ii = 0; ii < fileNames.length; ++ii) {
        stats.push(stat(fileNames[ii]));
    }
    wait(stats);
 
    // Print file size
    for (var ii = 0; ii < fileNames.length; ++ii) {
        console.log(fileNames[ii]+ ': '+ stats[ii].get().size);
    }
}).run();

var Future = require('fibers/future'), wait = Future.wait;
 
// This function returns a future which resolves after a timeout. This
// demonstrates manually resolving futures.
function sleep(ms) {
    var future = new Future;
    setTimeout(function() {
        future.return();
    }, ms);
    return future;
}
 
// You can create functions which automatically run in their own fiber and
// return futures that resolve when the fiber returns (this probably sounds
// confusing.. just play with it to understand).
var calcTimerDelta = function(ms) {
    var start = new Date;
    sleep(ms).wait();
    return new Date - start;
}.future(); // <-- important!
 
// And futures also include node-friendly callbacks if you don't want to use
// wait()
calcTimerDelta(2000).resolve(function(err, val) {
    console.log('Set timer for 2000ms, waited '+ val+ 'ms');
});

/**
 * Instantiate a new Fiber. You may invoke this either as a function or as
 * a constructor; the behavior is the same.
 *
 * When run() is called on this fiber for the first time, `fn` will be
 * invoked as the first frame on a new stack. Execution will continue on
 * this new stack until `fn` returns, or Fiber.yield() is called.
 *
 * After the function returns the fiber is reset to original state and
 * may be restarted with another call to run().
 */
function Fiber(fn) {
    [native code]
}
 
/**
 * `Fiber.current` will contain the currently-running Fiber. It will be
 * `undefined` if there is no fiber (i.e. the main stack of execution).
 *
 * See "Garbage Collection" for more information on responsible use of
 * `Fiber.current`.
 */
Fiber.current = undefined;
 
/**
 * `Fiber.yield()` will halt execution of the current fiber and return control
 * back to original caller of run(). If an argument is supplied to yield(),
 * run() will return that value.
 *
 * When run() is called again, yield() will return.
 *
 * Note that this function is a global to allow for correct garbage
 * collection. This results in no loss of functionality because it is only
 * valid to yield from the currently running fiber anyway.
 *
 * Note also that `yield` is a reserved word in Javascript. This is normally
 * not an issue, however some code linters may complain. Rest assured that it
 * will run fine now and in future versions of Javascript.
 */
Fiber.yield = function(param) {
    [native code]
}
 
/**
 * run() will start execution of this Fiber, or if it is currently yielding,
 * it will resume execution. If an argument is supplied, this argument will
 * be passed to the fiber, either as the first parameter to the main
 * function [if the fiber has not been started] or as the return value of
 * yield() [if the fiber is currently yielding].
 *
 * This function will return either the parameter passed to yield(), or the
 * returned value from the fiber's main function.
 */
Fiber.prototype.run = function(param) {
    [native code]
}
 
/**
 * reset() will terminate a running Fiber and restore it to its original
 * state, as if it had returned execution.
 *
 * This is accomplished by causing yield() to throw an exception, and any
 * futher calls to yield() will also throw an exception. This continues
 * until the fiber has completely unwound and returns.
 *
 * If the fiber returns a value it will be returned by reset().
 *
 * If the fiber is not running, reset() will have no effect.
 */
Fiber.prototype.reset = function() {
    [native code]
}
 
/**
 * throwInto() will cause a currently yielding fiber's yield() call to
 * throw instead of return gracefully. This can be useful for notifying a
 * fiber that you are no longer interested in its task, and that it should
 * give up.
 *
 * Note that if the fiber does not handle the exception it will continue to
 * bubble up and throwInto() will throw the exception right back at you.
 */
Fiber.prototype.throwInto = function(exception) {
    [native code]
}

/**
 * Returns a future-function which, when run, starts running the target
 * function and returns a future for the result.
 * 
 * Example usage: 
 * var funcy = function(arg) {
 *   return arg+1;
 * }.future();
 * 
 * funcy(1).wait(); // returns 2
 */
Function.prototype.future = function() { ... }
 
/**
 * Future object, instantiated with the new operator.
 */
function Future() {}
 
/**
 * Wrap a node-style async function to return a future in place of using a callback.
 * 
 * fn - the function to wrap
 * idx - the maximum number of arguments the function can take
 * 
 * Example usage: Future.wrap(asyncFunction, 2)(arg1, arg2).wait()
 */
Future.wrap = function(fn, idx) { ... }
 
/**
 * Wait on a series of futures and then return. If the futures throw an exception this function
 * /won't/ throw it back. You can get the value of the future by calling get() on it directly. If
 * you want to wait on a single future you're better off calling future.wait() on the instance.
 * 
 * Example usage: Future.wait(aFuture, anotherFuture)
 */
Future.wait = function(/* ... */) { ... }
 
/**
 * Return the value of this future. If the future hasn't resolved yet this will throw an error.
 */
Future.prototype.get = function() { ... }
 
/**
 * Mark this future as returned. All pending callbacks will be invoked immediately.
 * 
 * value - the value to return when get() or wait() is called.
 * 
 * Example usage: aFuture.return(value)
 */
Future.prototype.return = function(value) { ... }
 
/**
 * Throw from this future as returned. All pending callbacks will be invoked immediately.
 * Note that execution will continue normally after running this method, 
 * so make sure you exit appropriately after running throw()
 * 
 * error - the error to throw when get() or wait() is called.
 * 
 * Example usage: aFuture.throw(new Error("Something borked"))
 */
Future.prototype.throw = function(error) { ... }
 
/**
 * "detach" this future. Basically this is useful if you want to run a task in a future, you
 * aren't interested in its return value, but if it throws you don't want the exception to be
 * lost. If this fiber throws, an exception will be thrown to the event loop and node will
 * probably fall down.
 */
Future.prototype.detach = function() { ... }
 
/**
 * Returns whether or not this future has resolved yet.
 */
Future.prototype.isResolved = function() { ... }
 
/**
 * Returns a node-style function which will mark this future as resolved when called.
 * 
 * Example usage: 
 *   var errback = aFuture.resolver();
 *   asyncFunction(arg1, arg2, etc, errback)
 *   var result = aFuture.wait();
 */
Future.prototype.resolver = function() { ... }
 
/**
 * Waits for this future to resolve and then invokes a callback.
 *
 * If only one argument is passed it is a standard function(err, val){} errback.
 *
 * If two arguments are passed, the first argument is a future which will be thrown to in the case
 * of error, and the second is a function(val){} callback.
 */
Future.prototype.resolve = function(/* errback or future, callback */) { ... }
 
/**
 * Propogate results to another future.
 * 
 * Example usage: future1.proxy(future2) // future2 gets automatically resolved with however future1 resolves
 */
Future.prototype.proxy = function(future) { ... }
 
/**
 * Differs from its functional counterpart in that it actually resolves the future. Thus if the
 * future threw, future.wait() will throw.
 */
Future.prototype.wait = function() { ... }

var fiber = Fiber(function() {
    while (true) {
        try {
            Fiber.yield();
        } catch(e) {}
    }
});
fiber.run();

var fiber = Fiber(function() {
    var that = Fiber.current;
    Fiber.yield();
}
fiber.run();
fiber = undefined;