trxcllnt

var noop = require("rx/support/noop");
var try_catch = require("rx/support/try-catch");
var flatten_args = require("rx/support/arguments-flatten");
var errorObj = require("rx/support/error-object");

function Generator(destinationOrNext, _throw, _return) {
    if(destinationOrNext && typeof destinationOrNext === "object") {
        this.result = destinationOrNext.result || { done: false };
        this.destination = destinationOrNext;
    } else {

trxcllnt

/* output *//*
var result;
var acc = 1, x = 10;
while (true) {
    if (x <= 1) {
        // non-recursive return invocations aren't rewritten
        acc = log(acc);
        break;
    } else {
        acc = acc * x;

trxcllnt

/*output*//*
var foo = 'd', bar = 'e';
console.log('a', 'b', 'c', foo, bar);
console.log('a', 'b', 'c', foo, 2, 3, 4, 5);
console.log('a', 'c', 'b');
console.log('a', 'd', 'b', 'f', 'e', 'g', foo);
function veryLongFunction() {
    console.log.apply(console, arguments);
}
veryLongFunction('a', 'b', 'c', 'd', 'e', 'f');

trxcllnt

/* output:
legend:
    current: Scheduled concurrently by the CurrentThread scheduler.
    recursive: Scheduled recursively by the Immediate scheduler.
    setTimeout: Scheduled asynchronously by the Timeout scheduler.
    blocking-current: Scheduled to block concurrently by the CurrentThread scheduler.
    blocking-recursive: Scheduled to block recursively by the Immediate scheduler.

setTimeout a 0
setTimeout b 0

trxcllnt

macro flatMapVars { rule { } => { } }
macro concatVars { rule { } => { } }
macro flatMapCond { rule { } => { true } }
macro concatsCond { rule { } => { true } }
macro concatBlocks { rule { } => { } }

// wrapArgs(x, i, a) .foo(function (y, j, b) { return y + 1; }) ... ;
macro wrapArgs {
    function(stxs, context) {
        var name_stx = stxs[0];

trxcllnt

var Ix = require('ix'),
    Rx = require('rx'),
    Enumerable = Ix.Enumerable,
    Enumerator = Ix.Enumerator,
    Observable = Rx.Observable;

Observable.permute = function(root, hasPermutation, resultSelector) {
    return Observable
        .returnValue({ value: root, depth: -1 })
        .expandRecursive(function(wrapper) {

trxcllnt

macro parameters {
    rule { ($arguments ...) } => { (params ($arguments ...)) }
}

macro params {
    // group matchers
    rule { ($x:ident = $y:expr , $rest:params (,) ...) } => { $x , $rest (,) ... }
    rule { ($x:ident , $rest:params (,) ...) } => { $x , $rest (,) ... }
    rule { ($x:ident = $y:expr) } => { $x }

trxcllnt

// Zone.create = Observable.create
// Zone#setCallback = Observable#forEach/Observable#subscribe
// Zone#then = Observable#map
// Zone#catch = Observable#catch
// 
// A little stub of some zone examples that map 1-1 with Rx. Instead of a zone global,
// the "zone" object is passed in to the function we created the Zone with.
// 
// This allows us to run multiple Zones in parallel, for example, if we want to await
// two run two asynchronous operations (say, a file-read and a network request) at the

trxcllnt

var Subscriber = require('./Subscriber'),
    noop = require('./support/noop')
    ;

module.exports = (function Observable() {
    
    function fixDisposable(subscriber, disposable) {
        var disposableType;
        if(disposable != null) {
            if((disposableType = typeof disposable) === 'function') {

trxcllnt

// Have to do this to browserify Rx :/
window.global = window;

var Rx = require('rx');

Rx.Observable.interval(100).subscribe(function(i) {
    console.log(i);
});