anchor.diff:                | BitshiftLeft | BitshiftRight
   and UnaryOps = LogicalNot | BitwiseNot
   
  +// Mutations are changes in already declared variables, arrays, records, etc.
   and VarMutationRec =    { varName : PosAdorn<string> }
   and ArrayMutationRec =  { array : PosAdorn<LeftAssign>; index : PosAdorn<Expr> }
   and RecordMutationRec = { record : PosAdorn<LeftAssign>; fieldName : PosAdorn<string> }
  
positive.code:                | ArrayMutation of ArrayMutationRec
                 | RecordMutation of RecordMutationRec
  
  let unwrap<'a> ((_, _, c) : PosAdorn<'a>) = c
  let getPos<'a> ((a, _, _) : PosAdorn<'a>) = a
  let getType<'a> ((_, b, _) : PosAdorn<'a>) = b
  let dummyPos : Position = {pos_fname=""
                             pos_lnum = -1
                             pos_bol = -1
                             pos_cnum = -1}
  let dummyWrap<'a> c : PosAdorn<'a> = ((dummyPos, dummyPos), None, c)
  let clean<'a> ((_, _, c) : PosAdorn<'a>) : PosAdorn<'a> = dummyWrap c
  let cleanAll haystack = TreeTraversals.map1 (fun pos -> dummyPos) haystack
  
  let wrapWithType<'a> t c : PosAdorn<'a> = ((dummyPos, dummyPos), Some t, c)
  
  let templateToTemplateApply template =
  
negative.code:             | MatchTuple of PosAdorn<PosAdorn<Pattern> list>
              | MatchEmpty
  
  // Elements of a function clause.
  and FunctionClause = {returnTy : PosAdorn<TyExpr>; arguments : PosAdorn<(PosAdorn<TyExpr> * PosAdorn<string>) list>; body : PosAdorn<Expr>}
  
  // Module qualifier.
  and ModQualifierRec = { module_ : PosAdorn<string>; name : PosAdorn<string> }
  
  and Direction = Upto
                | Downto
  
  // Other AST objects and their definitions. Most of them are explained within their names.
  // Binary operation
  and BinaryOpRec =     { left : PosAdorn<Expr>; op : PosAdorn<BinaryOps>; right : PosAdorn<Expr> }
  and IfElseRec =       { condition : PosAdorn<Expr>; trueBranch : PosAdorn<Expr>; falseBranch : PosAdorn<Expr> }
  and LetRec =          { left : PosAdorn<Pattern>; right : PosAdorn<Expr> }
  // Variable assign
  and AssignRec =       { left : PosAdorn<LeftAssign>; right : PosAdorn<Expr>; ref : PosAdorn<bool> }
  and ForLoopRec =      { typ : PosAdorn<TyExpr>; varName : PosAdorn<string>; start : PosAdorn<Expr>; direction : PosAdorn<Direction>; end_ : PosAdorn<Expr>; body : PosAdorn<Expr> }
  and WhileLoopRec =    { condition : PosAdorn<Expr>; body : PosAdorn<Expr> }
  and DoWhileLoopRec =  { condition : PosAdorn<Expr>; body: PosAdorn<Expr> }
  // Pattern matching
  and CaseRec =         { on : PosAdorn<Expr>; clauses : PosAdorn<(PosAdorn<Pattern> * PosAdorn<Expr>) list> }
  // Unary operation
  and UnaryOpRec =      { op : PosAdorn<UnaryOps>; exp : PosAdorn<Expr> }
  and RecordAccessRec = { record : PosAdorn<Expr>; fieldName : PosAdorn<string> }
  and ArrayAccessRec =  { array : PosAdorn<Expr>; index : PosAdorn<Expr> }
  and VarExpRec =       { name : PosAdorn<string> }
  // Lambda function
  and LambdaRec =       { clause : PosAdorn<FunctionClause> }
  and InternalDeclareVarExpRec = { varName : PosAdorn<string>; typ : PosAdorn<TyExpr> option; right : PosAdorn<Expr> }
  and InternalValConAccessRec = { valCon : PosAdorn<Expr>; typ : PosAdorn<TyExpr> }
  // Function call/apply
  and CallRec =         { func : PosAdorn<Expr>; args : PosAdorn<PosAdorn<Expr> list> }
  // Applying the template of a function
  and TemplateApplyExpRec = { func : PosAdorn<Expr>; templateArgs : PosAdorn<TemplateApply> }
  and RecordExprRec =   { recordTy : PosAdorn<TyExpr>; templateArgs : PosAdorn<TemplateApply> option; initFields : PosAdorn<(PosAdorn<string> * PosAdorn<Expr>) list> }
  and ArrayMakeExpRec = { typ : PosAdorn<TyExpr>; initializer : PosAdorn<Expr> }
  