anchor.diff:  // Use these to apply a template (ex: when calling a function with a template)
   and TemplateApply = { tyExprs : PosAdorn<PosAdorn<TyExpr> list>; capExprs : PosAdorn<PosAdorn<CapacityExpr> list> }
   
  +// Capacities are used for making lists and arrays of fixed maximum sizes.
   and CapacityArithOp = CAPPLUS | CAPMINUS | CAPMULTIPLY | CAPDIVIDE
   and CapacityOpRec = { left : PosAdorn<CapacityExpr>; op : PosAdorn<CapacityArithOp>; right : PosAdorn<CapacityExpr> }
   and CapacityExpr = CapacityNameExpr of PosAdorn<string>
                    | CapacityOp of CapacityOpRec
                    | CapacityConst of PosAdorn<string>
   
  +// The language is statically typed, and so there must be support for Type Expressons and their applications
  +// (applying a typed datatype, typed arrays, typed functions definitions, a list of base types).
   and TyApplyRec = { tyConstructor : PosAdorn<TyExpr>; args : PosAdorn<TemplateApply> }
   and ArrayTyRec = { valueType : PosAdorn<TyExpr>; capacity : PosAdorn<CapacityExpr> }
   and FunTyRec = { template : PosAdorn<Template> option; source : ModQualifierRec option; args : PosAdorn<TyExpr> list; returnType : PosAdorn<TyExpr> }
  
positive.code: 
  open Microsoft.FSharp.Text.Lexing
  
  type Module = Module of PosAdorn<Declaration> list
  
  // Tuple of starting position and ending position
  and PosAdorn<'a> = (Position * Position) * TyExpr option * 'a
  
  // Top level declarations
  and FunctionRec = { name     : PosAdorn<string>; 
                      template : PosAdorn<Template> option;
                      clause   : PosAdorn<FunctionClause> }
  
  and RecordRec =   { name     : PosAdorn<string>;
                      fields   : PosAdorn<(TyExpr * string) list>;
                      template : PosAdorn<Template> option }
  
  and ValueCon =    PosAdorn<string> * (PosAdorn<TyExpr> option)
  and UnionRec =    { name     : PosAdorn<string>;
                      valCons  : PosAdorn<ValueCon list>;
                      template : PosAdorn<Template> option }
  
  and LetDecRec = { varName : PosAdorn<string>;
                    typ     : PosAdorn<TyExpr>;
                    right   : PosAdorn<Expr>; }
  
  and Declaration = FunctionDec   of FunctionRec
                  | RecordDec     of RecordRec
                  | UnionDec      of UnionRec
  
negative.code:                | ArrayMutation of ArrayMutationRec
                 | RecordMutation of RecordMutationRec
  
  // Takes in a wrapped AST object, returns the object within the PosAdorn.
  let unwrap<'a> ((_, _, c) : PosAdorn<'a>) = c
  // Takes in a wrapped AST object, returns the starting position.
  let getPos<'a> ((a, _, _) : PosAdorn<'a>) = a
  // Takes in a wrapped AST object, returns the ending position.
  let getType<'a> ((_, b, _) : PosAdorn<'a>) = b
  // Dummy position used for initializing positions on PosAdorns
  let dummyPos : Position = {pos_fname=""
                             pos_lnum = -1
                             pos_bol = -1
                             pos_cnum = -1}
  let dummyWrap<'a> c : PosAdorn<'a> = ((dummyPos, dummyPos), None, c)
  // Cleans up the wrapping around an AST object, returns it to default dummy values.
  let clean<'a> ((_, _, c) : PosAdorn<'a>) : PosAdorn<'a> = dummyWrap c
  let cleanAll haystack = TreeTraversals.map1 (fun pos -> dummyPos) haystack
  
  // Add typing to a PosAdorn.
  let wrapWithType<'a> t c : PosAdorn<'a> = ((dummyPos, dummyPos), Some t, c)
  
  let templateToTemplateApply template =
  