     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
 

  # is one. Expressions serve as the building blocks of many other rules, making
  # them somewhat circular.
  Expression: [
    o "Value"
    o "Invocation"
    o "Code"
    o "Operation"
    o "Assign"
    o "If"
    o "Try"
    o "While"
    o "For"
    o "Switch"
    o "Extends"
    o "Class"
    o "Existence"
    o "Comment"
  ]

  # An indented block of expressions. Note that the [Rewriter](rewriter.html)
  # will convert some postfix forms into blocks for us, by adjusting the
  # token stream.
  Block: [
    o "INDENT Body OUTDENT",                    -> $2
    o "INDENT OUTDENT",                         -> new Expressions
    o "TERMINATOR Comment",                     -> Expressions.wrap [$2]
  ]

  # A literal identifier, a variable name or property.
  Identifier: [
    o "IDENTIFIER",                             -> new Literal $1
  ]

  # Alphanumerics are separated from the other **Literal** matchers because
  # they can also serve as keys in object literals.
  AlphaNumeric: [
    o "NUMBER",                                 -> new Literal $1
    o "STRING",                                 -> new Literal $1
  ]

  # All of our immediate values. These can (in general), be passed straight
  # through and printed to JavaScript.
  Literal: [
    o "AlphaNumeric"
    o "JS",                                     -> new Literal $1
    o "REGEX",                                  -> new Literal $1
    o "BOOL",                                   -> new Literal $1
  ]

  # Assignment of a variable, property, or index to a value.
  Assign: [
    o "Assignable = Expression",                -> new Assign $1, $3
    o "Assignable = INDENT Expression OUTDENT", -> new Assign $1, $4
  ]

  # Assignment when it happens within an object literal. The difference from


  # The list of parameters that a function accepts can be of any length.
  ParamList: [
    o '',                                       -> []
    o 'Param',                                  -> [$1]
    o 'ParamList , Param',                      -> $1.concat $3
  ]

  # A single parameter in a function definition can be ordinary, or a splat
  # that hoovers up the remaining arguments.
  Param: [
    o 'PARAM',                                  -> new Literal $1
    o 'PARAM ...',                              -> new Param $1, false, true
    o '@ PARAM',                                -> new Param $2, true
    o '@ PARAM ...',                            -> new Param $2, true, true
  ]

  # A splat that occurs outside of a parameter list.
  Splat: [
    o 'Expression ...',                         -> new Splat $1
  ]

  # Variables and properties that can be assigned to.
  SimpleAssignable: [
    o 'Identifier',                             -> new Value $1
    o 'Value Accessor',                         -> $1.push $2
    o 'Invocation Accessor',                    -> new Value $1, [$2]
    o 'ThisProperty'
  ]

  # Everything that can be assigned to.
