anchor.diff:       ;
   
   inheritBlock
  -     :    nameRef ( '<-' nameRef )+ blockStatements
  +     :    nameRef ( '<-' exprList Label? )+ blockStatements?
        ;
   
   block
  
positive.code: 
  expr
       :    '(' exprList ')'                         #groupExpr
       |    expr Label? '->' expr Label?             #composeExpr
       |    expr '(' expr? ')'                       #executeExpr
       |    expr '<' expr '>'                        #argExpr
       |    sign=( PLUS | MINUS ) expr               #unarySignExpr
  
negative.code: //   1. "Inheritance"
  //
  //   I want to provide for composing and defining at the same time, which
  //   is what we need to mimic inheritance. So we want to do something like this:
  //        a = base_obj -> ,
  //        with a
  //             ...
  //   If we want to compose with a copy of the base object (so that we can't alter it via
  //   the composition) then we can use the `~~` expansion operator, which creates a copy
  //   of the object, instead of a reference (which is the normal result of composition).
  //   The `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 also defines and opens a new scope for further
  //   declarations in the block statements that follow.
  
  //   2. References
  //
  //   I've been thinking a lot about this, and I think all objects will have normal
  //   reference semantics. If one wants a copy instead of a reference, use the expansion
  //   operator `~~`. If we decide to do automatic reference counting instead of GC, then
  //   we can use the ampersand `&` to indicate a "weak" reference (meaning "strong" would
  //   be the default). Copies will be "copy on write" to make them more efficient.
  
  //   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 `#` 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`, where we have an `$obj` scope, 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
  //        comp@base.some_func()   //(1)
  //        comp.some_func()   //(2)
  //   Statement (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 statement (2)
  //   will undergo a normal name resolution search starting with `oth_obj`.
  //   Badges don't make sense on the rightmost end of a composition, because that will be
  //   the "closest" end of the stack and you don't need a badge to reach it. Later on if
  //   a saved composition is composed with something else, a badge would apply to the
  //   (previously unavailable for badging) "nearest" or "right-most" end.
  //        next_comp = comp#foo -> next_obj
  //   is equivalent to adding the badge `foo` to `oth_obj` from the original composition:
  //        next_comp = base_obj#base -> oth_obj#foo -> next_obj
  //   That also means that this:
  //        some_obj#foo -> some_func()
  //   is allowed but is sort of pointless, because inside the function, using `@foo` is not
  //   necessary: that is where scope searches would start anyway (i.e., the badge isn't
  //   "skipping" anything).
  
  
  
  