anchor.diff:                  | 1 -> inlineLet expr var value body
                   | _ -> expr
           | Sequential (a, b) when isMostlyPure a -> b
  -        | FieldGet (NewObject fs, Constant (String fieldName)) ->
  -            let mutable nonPureBefore = []
  -            let mutable nonPureAfter = []
  -            let mutable fieldValue = None
  -            for n, v in fs do
  -                if n = fieldName then
  -                    fieldValue <- Some v
  -                else 
  -                    if not (isMostlyPure v) then
  -                        match fieldValue with
  -                        | None -> nonPureBefore <- v :: nonPureBefore
  -                        | _ -> nonPureAfter <- v :: nonPureAfter
  -            let fieldValue = defaultArg fieldValue (Constant Undefined)
  -            let result =
  -                Seq.fold (fun e v -> Sequential (v, e)) fieldValue nonPureBefore 
  -            if List.isEmpty nonPureAfter then
  -                result 
  -            else 
  -                let resVar = Id fieldName
  -                Let (resVar, result, 
  -                    Seq.fold (fun e v -> Sequential (v, e)) (Var resVar) nonPureAfter
  -                )
  -        | FieldGet (NewArray fs, Constant (Integer index)) ->
  -            let mutable nonPureBefore = []
  -            let mutable nonPureAfter = []
  -            let mutable fieldValue = None
  -            let mutable i = 0
  -            for v in fs do
  -                if i = int index then
  -                    fieldValue <- Some v
  -                else 
  -                    if not (isMostlyPure v) then
  -                        match fieldValue with
  -                        | None -> nonPureBefore <- v :: nonPureBefore
  -                        | _ -> nonPureAfter <- v :: nonPureAfter
  -                i <- i + 1
  -            let fieldValue = defaultArg fieldValue (Constant Undefined)
  -            let result =
  -                Seq.fold (fun e v -> Sequential (v, e)) fieldValue nonPureBefore 
  -            if List.isEmpty nonPureAfter then
  -                result 
  -            else 
  -                let resVar = Id ("item" + string index)
  -                Let (resVar, result, 
  -                    Seq.fold (fun e v -> Sequential (v, e)) (Var resVar) nonPureAfter
  -                )
           | _ -> expr
   
       // keep rewriting with `step` bottom-up until reach a fixpoint
  
positive.code:                 tr expr
          // used by functions with rest argument
          | Call (NewArray arr, Constant (String "concat"), [ NewArray rest ]) ->
              NewArray (arr @ rest |> List.map tr)    
          | _ -> tr expr
       
      clean expr   
  
negative.code:                     | Var v when v = var -> false
                      | _ -> Children e |> List.forall alwaysInterop  
                  if alwaysInterop body then
                      Let(var, jsFunc |> clean |> WithPosOf value, body |> BottomUp (function WithInterop -> Var var | e -> e) |> tr)
                  else tr expr
              match value with
              | TupledLambda (vars, lBody) ->
  