     o 'SimpleAssignable --',                    -> new Op '--', $1, null, true
     o 'SimpleAssignable ++',                    -> new Op '++', $1, null, true
 
+    # [The existential operator](http://jashkenas.github.com/coffee-script/#existence).
+    o 'Expression ?',                           -> new Existence $1
+
     o 'Expression +  Expression',               -> new Op '+' , $1, $3
     o 'Expression -  Expression',               -> new Op '-' , $1, $3
 

  # where only values are accepted, wrapping it in parentheses will always do
  # the trick.
  Parenthetical: [
    o "( Expression )",                         -> new Parens $2
  ]

  # The condition portion of a while loop.
  WhileSource: [
    o "WHILE Expression",                       -> new While $2
    o "WHILE Expression WHEN Expression",       -> new While $2, guard: $4
    o "UNTIL Expression",                       -> new While $2, invert: true
    o "UNTIL Expression WHEN Expression",       -> new While $2, invert: true, guard: $4
  ]

  # The while loop can either be normal, with a block of expressions to execute,
  # or postfix, with a single expression. There is no do..while.
  While: [
    o "WhileSource Block",                      -> $1.addBody $2
    o "Statement WhileSource",                  -> $2.addBody Expressions.wrap [$1]
    o "Expression WhileSource",                 -> $2.addBody Expressions.wrap [$1]
    o "Loop",                                   -> $1
  ]

  Loop: [
    o "LOOP Block",                             -> new While(new Literal 'true').addBody $2
    o "LOOP Expression",                        -> new While(new Literal 'true').addBody Expressions.wrap [$2]
  ]

  # Array, object, and range comprehensions, at the most generic level.


  # A return statement from a function body.
  Return: [
    o 'RETURN Expression',                      -> new Return $2
    o 'RETURN',                                 -> new Return
  ]

  # A block comment.
  Comment: [
    o 'HERECOMMENT',                            -> new Comment $1
  ]

  # The **Code** node is the function literal. It's defined by an indented block
  # of **Expressions** preceded by a function arrow, with an optional parameter
  # list.
  Code: [
    o 'PARAM_START ParamList PARAM_END FuncGlyph Block', -> new Code $2, $5, $4
    o 'FuncGlyph Block',                        -> new Code [], $2, $1
  ]

  # CoffeeScript has two different symbols for functions. `->` is for ordinary
  # functions, and `=>` is for functions bound to the current value of *this*.
  FuncGlyph: [
    o '->',                                     -> 'func'
    o '=>',                                     -> 'boundfunc'
  ]

  # An optional, trailing comma.
