anchor.diff:  
   expr
        :    '(' exprList ')'                         #groupExpr
  -     |    expr Label? '->' expr Label?             #composeExpr
  +     |    expr Label? '->' expr                    #composeExpr
        |    expr '(' expr? ')'                       #executeExpr
        |    expr '<' expr '>'                        #argExpr
        |    sign=( PLUS | MINUS ) expr               #unarySignExpr
  
positive.code: //   1. "Inheritance"
  //
  //   I want to provide for composing and defining at the same time, which
  //   is what we need to mimic inheritance. In most cases we don't want to modify the
  //   original (or "base" object). So we want to do something like this:
  //        a = ~~base_obj -> ,
  //        with a
  //             ...
  //   The tilde expansion creates a copy of the object, instead a reference (which is the
  //   normal result of composition), which is then composed with an empty array `,`.
  //   And then a `with` statement allows us to declare stuff inside the newly composed
  //   object.
  //   All of the above can be accomplished with:
  //        a <- base_obj
  //             ...
  //   This is a form of composition, but it composes with a copy of the original, and
  //   allows for block statements to follow. If we make it right-associative, we can chain
  //   these together as well.
  
  //   2. References
  //
  //   How do we create references outside of composing? My thoughts so far are to use
  //   ampersand, like C and PHP.
  //        a = ( parent=&parent_obj, name="fred" )
  //   Maybe this is a weak reference by default, and double ampersand makes it strong.
  
  //   3. Badges
  //
  //   When composing, a "badge" can be assigned to the intermediate objects, giving us a
  //   way to later jump directly to that object's scope for name resolution, skipping over
  //   the normal hierarchy chain.
  //   Use the pound sign (octothorp) to badge an object during composition:
  //        base_obj#base -> oth_obj#child -> some_func()
  //   Later use the ampersand to access the badged object directly.
  //   For example, within `some_func` we could write:
  //        @base.parent_func()
  //   which is equivalent to
  //        $obj@base.parent_func()
  //   Or, if we are saving the composition:
  //        comp = base_obj#base -> oth_obj#child
  //        comp@base.some_func()   //(1)
  //        comp.some_func()   //(2)
  //   Version 1 will grab the function `some_func` defined on the original base_obj array,
  //   skipping past any such object if defined on `oth_obj`; whereas version 2 will undergo
  //   a normal name resolution search starting with `oth_obj`.
  
  
  
  
negative.code:      ;
  
  inheritBlock
       :    nameRef ( '<-' exprList Label? )+ blockStatements?
       ;
  
  block
  