Goodbye CoffeeScript, Hello TypeScript

does

  > It’s reasonable to assume "foo bar and hello world" will compile to either:
  > foo(bar) && hello(world)
  > foo(bar && hello(world))

    sum([]) = 0.
    sum([H|T]) = H + sum(T).

    function sum(ary) {
      var i = ary.length,
       res;
      while(--i) {
        res += ary[i];
      }
      return res;
    }
    function sum(array) {
      return array.reduce((a, b) => a + b);
    }

    function sum(array) {
      let acc = 0;
      for(let val of array) {
        acc += val;
      }
      return acc;
    }
    array.reduce((a, b) => a + b, 0);
    sum = (values) ->
      values.reduce (result, x) -> result + x
     foo () (irb) :2: warning: don't put space before argument parentheses .
  (and (foo bar) (hello world))
    foo bar && hello world

    foo bin bar && hello world
  class GraphQuery extends Query {
    static parse(object: any): Try<GraphQuery> {
      return TimeRange.parse(object.over).flatMap((timeRange: TimeRange) => {
        return Filter.parse(object.where).flatMap((filter: Option<Filter>) => {
          return GroupBy.parse(object.by).flatMap((groupBy: Option<GroupBy>) => {
            return new Success(new GraphQuery(
              filter,
              groupBy,
              timeRange
            ));
          });
        });
      });
    }
  }

  parse : Any -> Try GraphQuery
  parse object = do 
    timeRange <- TimeRange.parse object.over
    filter    <- Filter.parse object.where
    groupBy   <- GroupBy.parse object.by
    return (createGraphQuery filter groupBy timeRange)

    >   parse : Any -> Try GraphQuery
    >   parse object = do 
    >     timeRange <- TimeRange.parse object.over
    >     filter    <- Filter.parse object.where
    >     groupBy   <- GroupBy.parse object.by
    >     return (createGraphQuery filter groupBy timeRange)

    parse = ({by, over, where}) => {
      timeRange = TimeRange.parse(over)
      filter    = Filter.parse(where)
      groupBy   = GroupBy.parse(by)
      return createGraphQuery(filter, groupBy, timeRange)
    }

    parse = ({by, over, where}) => 
      createGraphQuery(
        Filter.parse(where),
        GroupBy.parse(by),
        TimeRange.parse(over));

    parse = ({by, over, where}) => 
      createGraphQuery(
        Filter(where),
        GroupBy(by),
        TimeRange(over));

    parse = ({by, over, where}) => createGraphQuery( Filter(where), GroupBy(by), TimeRange(over) );

    parse = ({by, over, where}) => c(f(where), g(by), t(over));

    parse = ({b, o, w}) => c(f(w), g(b), t(o));

  class GraphQuery extends Query {
    static parse(object: any): Try<GraphQuery> {
      return TimeRange.parse(object.over)
        .combinedWith(() => Filter.parse(object.where) )
        .combinedWith(() => GroupBy.parse(object.by) )
        .withCombinedValues((timeRange, filter, groupBy) => {
          return new Success(new GraphQuery(filter, groupBy, timeRange));
        });
    }
  }

   join =: 1 : 0
    ((([:{.[:>{.),:[:([:<(>"0))"1[:{:[:1 2 0&|:[:>([:,u"0)#]) (pr y))
   )

   >&.@:/"1\and[:    NB. some nonsensical J phrase

   >&.@:/"1\&&[:

   * pure functions - all you said is equally true for Scheme
   * immutability - set-cdr! and many SRFIs: vectors, boxes, records...
   * curried by default - nope, not in Scheme either

   var a = 1;
   a = 2;

   window.someGlobal = 'foo';
    const a = {b: "foo"};
    a.b = "bar";
    const a = icepick.freeze({b: "foo"});

    var state = { foo: 1 };
    if(something) {
      state.bar = 2;
    }

  declare function map<T,U>(a:Array<T>, f: (T) => U):Array<U>

  i
  ++
  j

  class GraphQuery extends Query {
    static parse(object: any): Try<GraphQuery> {
      return TimeRange.parse(object.over).flatMap((timeRange: TimeRange) => {
        return Filter.parse(object.where).flatMap((filter: Option<Filter>) => {
          return GroupBy.parse(object.by).flatMap((groupBy: Option<GroupBy>) => {
            return new Success(new GraphQuery(
              filter,
              groupBy,
              timeRange
            ));
          });
        });
      });
    }
  }
			  ));
			}); // I
		  }); // love
		}); // TypeScript
	  }
	}

    > 3 == "3"
    true
    > 3 * "3"
    9
    > "a" * "b"
    NaN

    > true / false
    Infinity

    > setInterval(function(){ console.log("hi") }, "later")
    > hi
    > hi
    > hi
    > hi
    ...

  some_func = (callback) -> callback new Error 'boom'

  some_func (err) ->
    return console.log err if err
    console.log 'everything is fine'

    let some_func = callback => callback(new Error('boom'));

    let some_func = err => console.log(err || 'everything is fine');
    let some_func = (callback) => callback(new Error('boom'))

    let some_other_func = (err) => console.log(err || 'everything is fine')

    let some_func = co(function*() {
        try { 
            const someData = yield asyncRequest(some_url);
            console.log('asyncRequest resolved with %j', someData)
        }
        catch(e) {
            console.log('asyncRequest rejected with %j', e);
        }
    });
  * Comprehensions (more flexible with Coffeescript).  Wait, that's ES7 now.
  * Template strings
  * For .. Of loops
  * Destructing
  * Classes. ES2015 has an awful implementation of this, without allowing an syntax for binding methods.  Also enforces the somewhat arbitrary requirement of function properties only, as opposed to any type I choose.  Don't forget, mixins with Coffeescript classes is a breeze, but no support with ES2015.
  * Arrow functions.  Unnecessary syntax with ES2015 (the parens even without arguments), not to mention confusing implicit return.
  * Generators with ES2105.  If you find a use for these in front end web dev I'll buy you a beer.