anchor.diff:          Let (argId, NewArray [], t exit body ++ cycle ++ res)
       t id expr
   
  +// Transforms JavaScipt object creation with additional field setters
  +// into a single object literal 
  +let CollectObjLiterals expr =
  +    let (|PropSet|_|) expr =
  +        match expr with
  +        | Unary (UnaryOperator.``void``, FieldSet (Var objVar, Constant (String field), value))
  +        | FieldSet (Var objVar, Constant (String field), value) ->
  +            Some (objVar, (field, value))
  +        | _ -> None    
  +        
  +    let rec coll expr =
  +        match expr with
  +        | Let (objVar, NewObject objFields, Sequential (propSetters, Var v)) when v = objVar ->
  +            let rec getSetters acc e =
  +                match e with
  +                | Constant Null -> Some acc
  +                | Sequential (more, PropSet (v, fv)) when v = objVar ->
  +                    getSetters (fv :: acc) more
  +                | PropSet (v, fv) when v = objVar -> 
  +                    Some (fv :: acc)
  +                | _ -> None
  +            match getSetters [] propSetters with
  +            | Some s -> 
  +                objFields @ s 
  +                |> List.map (fun (f, vExpr) -> f, Transform coll vExpr)
  +                |> NewObject
  +            | _ -> Transform coll expr
  +        | _ -> Transform coll expr
  +
  +    coll expr        
  +     
   let Simplify expr =
   
       // fast-track Substitue: assume IsAlphaNormalized on all
  
positive.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 (Var f, [Var y])) when x = y ->
              Var f
          | 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 ->
  
negative.code:                     | _ -> expr
          | Sequential (a, b) when isPure a ->
              b
          | _ ->
              expr
  
  