The minimalist fast-track to fluency in CoffeeScript

instant-coffee.md

Instant Coffee

CoffeeScript ⇒ JavaScript

---

0. Arrows, not function:

• e.g. ->, (a) ->, (a,b) ->, curried = (a) -> (b) -> ···
• => binds this from outer scope
• generator function if body contains yield

0. Indentation, not {···}:

• both for code blocks, and (optionally) for key: value object literals
• inside multiline object/array literals, end-line comma delimiters are optional

0. Expressions, not statements:

• expression bodies evaluate to the value of their tail-position term
  • e.g. “implicit return” in function body: ask = -> 42
• comprehensions evaluate to an array of each iteration’s evaluation

0. Assignment, not declaration:

• no var; identifier scope determined by first/outermost assignment
• use do to scope arbitrarily with params of IIFE, e.g.:
  • v = do (a, b=x) -> ··· ⇒ v = (function(a, b) {···})(a, x)

0. Operators:

• All the unary and binary operators of JS, except void, plus:
  • [@, C::] ⇒ [this(.), C.prototype(.)]
  • not x ⇒ !x
  • key of object ⇒ key in object
  • value in array ⇒ array.indexOf(value) >= 0
  • [is, isnt, and, or] ⇒ [===, !==, &&, ||]
  • x or= 42 ⇒ x || (x = 42) (likewise: ||=, and=, &&=)
  • existential operator ? (see below)
• Ternary conditional replaced by expression form of if–then–else

0. Conditionals:

• if–then–else if–else (negate: unless)
• Expression: e.g. v = if x then y else z ⇒ v = x ? y : z
• Postfix: e.g. x if y ⇒ if (y) {x}

0. Existence:

• x? ⇒ x != null (also catches undeclared x)
• x?.k ⇒ if x? then x.k else undefined (“null soaking”)
• x ? y ⇒ if x? then x else y (cf. x or y)
• x ?= v ⇒ if x? then x else x = v (cf. x or= v)

0. Loops:

• loop ⇒ while (true) {···}
• while cond ⇒ while (cond) {···} (negate: until)
• for value in array, for value, index in array
• for key of object, for key, value of object, for own key ···
• optional filter clause: for ··· when c ⇒ for ··· { if (c) {···} }
• inline body with then, e.g.: for v in a then do (v) -> ···

0. Comprehensions:

• e.g. a = (x+x for x in y) ⇒ array mapping x+x to each x in y

0. Constructors:

• block expression class C ⇒ IIFE that returns a constructor C
• at class-body scope level:
  • constructor: -> defines C (as function statement, hoisted)
  • @/this references C
  • name: method adds to prototype of C (equal to @::name = method)

0. Invocation (optional):

• Inline whitespace as implicit invocation paren (, e.g.:
  • f a, b ⇒ f(a, b)
  • fs = require 'fs'
  • data = JSON.parse fs.readFileSync 'data.json', 'utf8'
• right-associative; implicit matching ) runs to end of clause, e.g.:
  • f a + g b ⇒ f(a + g(b))
  • a + f g b ⇒ a + f(g(b))
  • f g b, c if a ⇒ if (a) { f(g(b, c)) }
  • if f a then g b else c ⇒ f(a) ? g(b) : c