anchor.diff:  *
   */
   
  -//	Stuff still floating around as ideas but not working in the grammar yet.
  -
  -//	1. "Inheritance"
  +//   Stuff still floating around as ideas but not working in the grammar yet.
  +
  +//   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
  
positive.code: assignBlock
       :    nameRef blockStatements
       |    exprList ':' blockStatements
       |	arrayLiteral blockStatements
       ;
  
  block
  
negative.code: //   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`.
  
  
  
  