đź’ˇ some minor language changes and lots of awesome additions
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


NOTE: The changes listed here are not included in, but instead dependent upon my Kickstarter project. The project has been funded and will allow me to make a fork that implements these changes once it is completed.

I would like this language to remain as close to a superset of coffeescript as possible, unlike the ever-diverging Coco. This means keeping the incompatible change list very small, which I believe I have done.

Full Change List

incompatible changes

  • newer, awesome class syntax/semantics (#1207, #640, strawman:maximally_minimal_classes)
    • constructor is the unique, unnamed top-level function
    • context of class body is the prototype (which makes @@ the constructor, see below)
    • regular assignments to @-vars for method definitions
  • change comprehension syntax to {python,harmony}-style [... for x in y] (harmony:array_comprehensions, #77, #2030, #1191)
  • bare super should not imply a call; it should simply be a reference to ClassName.__super__.constructor
  • lower precedence of infix operators to allow for more paren-free invocations (unfinished discussion with Jeremy)
    • also add a super-low-precedence application operator: $ in Haskell, <| in LiveScript
  • spaced (or newline-separated) member access to close implicit calls (#1495)
  • remove inline JS
  • block comments are comments, don't pass them through to the compilation target
  • in operator should perform an egal comparison, not strict equality comparison
  • disallow references to magic arguments variable (requires as-patterns, see below)

compatible changes


  • partially-applied operators and member accesses (gkz/LiveScript@37ef73b7, gkz/LiveScript#41)
  • unary operators are functions (gkz/LiveScript@c13b8a60)
  • backcalls, a flat call/cc via <-:
    • <- fn a; ...; b to fn(a, function(){ ...; return b; })
    • a <- fn b; ...; c to fn(b, function(a){ ...; return c; })
    • (a, b) <- fn c, <&>, d; ...; e to fn(c, function(a, b){ ...; return e; }, d)
    • preserve this by rewriting references as we do in bound functions
  • explicit tail calls via recur, as in clojure (#2665)
  • stepped ranges: [0..8 by 2] (#835)
  • Haskell's as-patterns: o@{p0: a@[b, c]} = obj, fn = (args@[a, b, c]...) ->
  • Haskell's function-infixing via backticks (kinda #915, #1429, gkz/LiveScript@fb548f23)
  • %% (mod) and // (integer division) operators (#1971)
  • min/max operators (satyr/coco): <?, >?
  • sugar for accessing the last element of an array-like, syntax TBD (#156)
  • @@ as sugar for @constructor
  • @0, @1, etc. for this[0], this[1], etc.
  • a.0.1 for a[0][1] (#918, #1334)
  • underscore in number literals; postfix alphabetic comments: 15_550km (#632, #857, #913)
  • quote-word (<[ word1 word2 ]>) (#582, #1211, others)
  • unary :: operator (#1220)
  • unicode alternatives for keywords/symbols (#2, #1679)
  • allow identifiers that are reserved words in JS but not coffee through use of unicode escape sequences (#1452)
  • {foo.bar} as shorthand for {bar: foo.bar} (#1089)
  • quoted member access (a."b-c" is a["b-c"]) to reserve postfix [] for indicating nondeterministic member access
  • unnamed splats in array destructuring and function parameters (#870)
  • single-value-skipping null syntax (#870)
  • Ruby's =~ regexp matching operator for the convenience of Ruby-ers (#1651, #1653, #115)
  • call superclass's extended method on extension (#710, #841, gist:612786)
  • yada-yada (#1142, satyr/coco)
  • {+flag}, {-flag} (#885)
  • (possibly) scheme-style argument accessor (if I can resolve ambiguity with a <b> c somehow) (#739)