anchor.diff:  let Optimize expr =
       expr
       |> AlphaNormalize
  +    |> RemoveUnusedThis
       |> Uncurry
       |> RemoveLoops
  +    |> CollectObjLiterals
       |> Simplify
   
   // Elaboration ----------------------------------------------------------------
  
positive.code:         Let (argId, NewArray [], t exit body ++ cycle ++ res)
      t id expr
  
  let Simplify expr =
  
      // fast-track Substitue: assume IsAlphaNormalized on all
  
negative.code: 
  // Optimization ---------------------------------------------------------------
  
  // Remove 'this' bindings from lambdas when it is not used in body
  let RemoveUnusedThis expr =
      let bound = HashSet()
      let rec rem expr =
          match expr with
          | Lambda (Some this, args, body) -> 
              bound.Add this |> ignore
              let bodyTr = Transform rem body
              if bound.Contains this then
                   bound.Remove this |> ignore
                   Lambda (None, args, bodyTr)
              else
                   Lambda (Some this, args, bodyTr)
          | Var v when bound.Contains v ->
              bound.Remove v |> ignore
              expr
          | _ -> Transform rem expr  
  
      rem expr
  
  /// Transforms local Let- or LetRecursive-bound curried lambda functions to
  /// multi-argument functions when such transformations are possible - the
  /// functions are strictly local, do not escape the scope, and are always
  