anchor.diff:              transformDecisionTreeSuccessAsExpr com ctx idx boundValues
   
           | Fable.Set(expr, kind, typ, value, range) ->
  -            transformSet com ctx range expr typ value kind
  +            let expr', stmts = transformSet com ctx range expr typ value kind
  +            match expr' with
  +            | Expression.NamedExpr({ Target = target; Value = _; Loc=_ }) ->
  +                let nonLocals =
  +                    match target with
  +                    | Expression.Name({Id=id}) -> [ ctx.BoundVars.NonLocals([id]) |> Statement.nonLocal ]
  +                    | _ -> []
  +                expr', nonLocals @ stmts
  +            | _ -> expr', stmts
   
           | Fable.Let(ident, value, body) ->
  -            // printfn "Fable.Let: %A" (ident, value, body)
  +            //printfn "Fable.Let: %A" (ident, value, body)
               if ctx.HoistVars [ident] then
                   let assignment, stmts = transformBindingAsExpr com ctx ident value
  -                let expr, stmts' = com.TransformAsExpr(ctx, body)
  -                let expr, stmts'' = transformSequenceExpr com ctx [ assignment; expr ]
  -                expr, stmts @ stmts' @ stmts''
  +                let bodyExpr, stmts' = com.TransformAsExpr(ctx, body)
  +                let expr, stmts'' = transformSequenceExpr' com ctx [ assignment; bodyExpr ] (stmts @ stmts')
  +                expr, stmts''
               else iife com ctx expr
   
           | Fable.LetRec(bindings, body) ->
  
positive.code:             optimizeTailCall com ctx range tc args
          | _ ->
              let expr, stmts = transformCall com ctx range callee callInfo
              stmts @ [ expr |> resolveExpr t returnStrategy ]
  
      let transformCurriedApplyAsStatements com ctx range t returnStrategy callee args =
          // Warn when there's a recursive call that couldn't be optimized?
  
negative.code:             optimizeTailCall com ctx range tc args
          | _ ->
              let expr, stmts = transformCurriedApply com ctx range callee args
              stmts @ (expr |> resolveExpr ctx t returnStrategy)
  
      // When expecting a block, it's usually not necessary to wrap it
      // in a lambda to isolate its variable context
  