anchor.diff:              | _ -> Transform coll expr
           | _ -> Transform coll expr
   
  -    coll expr        
  -     
  +    coll expr
  +
   let Simplify expr =
   
       // fast-track Substitue: assume IsAlphaNormalized on all
  
positive.code: 
  module IntelliFactory.JavaScript.Core
  
  open IntelliFactory.JavaScript
  module S = Syntax
  
  type Dictionary<'T1,'T2> = System.Collections.Generic.Dictionary<'T1,'T2>
  type HashSet<'T> = System.Collections.Generic.HashSet<'T>
  type Interlocked = System.Threading.Interlocked
  
  type SB = Syntax.BinaryOperator
  type SP = Syntax.PostfixOperator
  
negative.code:     let step expr =
          match expr with
          | Application (Lambda (None, args, body), xs) ->
              if List.length args = List.length xs then
                  let bind key value body = Let (key, value, body)
                  List.foldBack2 bind args xs body
              else expr
          | Application (Let (var, value, body), xs) ->
              Let (var, value, Application (body, xs))
          | Lambda (None, [x], Application (f, [Var y])) ->
              if x = y && isPure f then f else expr
          | Let (var, Let (v, vl, bd), body) ->
              Let (v, vl, Let (var, bd, body))
          | Let (var, value, body) when not var.IsMutable ->
              match value with
              | Constant _ | Global _ | Runtime ->
  