anchor.diff:              transformSet com ctx range expr typ value kind
   
           | Fable.Let(ident, value, body) ->
  -            transformLet com ctx ident value body
  +            // flatten nested let binding expressions
  +            let rec flatten acc expr =
  +                match expr with
  +                | Fable.Let(ident, value, body) ->
  +                    flatten ((ident, value)::acc) body
  +                | _ -> List.rev acc, expr
  +            let bindings, body = flatten [] fableExpr
  +            transformLet com ctx bindings body
               // if ctx.HoistVars [ident] then
               //     let assignment = transformBindingAsExpr com ctx ident value
               //     Expression.sequenceExpression([|assignment; com.TransformAsExpr(ctx, body)|])
  
positive.code: 
          | Fable.TryCatch (body, catch, finalizer, range) ->
              transformTryCatch com ctx range body catch finalizer
          // TODO: remove this catch-all
          | _ -> TODO_EXPR (sprintf "%A" expr)
  (*
      let rec transformAsStatements (com: IRustCompiler) ctx returnStrategy
                                      (expr: Fable.Expr): Rust.Stmt array =
  
negative.code:             let field = getField None expr fieldName
              mutableSet com ctx range typ field value
  
      let transformAsStmt (com: IRustCompiler) ctx (e: Fable.Expr) =
          let expr = com.TransformAsExpr(ctx, e)
          if e.Type = Fable.Unit
          then mkSemiStmt expr
          else mkExprStmt expr
  
      // flatten nested sequential expressions (depth first)
      let rec flattenSequential (expr: Fable.Expr) =
          match expr with
          | Fable.Sequential exprs ->
              List.collect flattenSequential exprs
          | _ -> [expr]
  
      let transformLet (com: IRustCompiler) ctx bindings body =
          let makeLetStmt (ident: Fable.Ident, value: Fable.Expr) =
              let isRef = false
              let isMut = ident.IsMutable
              let pat = mkIdentPat ident.Name isRef isMut
              let ty = transformType com ctx ident.Type
              let init = transformMaybeCloneRef com ctx value
              let local = mkLocal [] pat (Some ty) (Some init)
              mkLocalStmt local
          let letStmts = bindings |> List.map makeLetStmt
          let bodyStmts =
              match body with
              | Fable.Sequential exprs ->
                  let exprs = flattenSequential body
                  List.map (transformAsStmt com ctx) exprs
              | _ ->
                  [transformAsStmt com ctx body]
          (letStmts @ bodyStmts) |> mkBlock |> mkBlockExpr
  
      let transformSequential (com: IRustCompiler) ctx exprs =
          exprs
          |> List.map (transformAsStmt com ctx)
          |> mkBlock
          |> mkBlockExpr
  
      let transformIfThenElse (com: IRustCompiler) ctx range guard thenBody elseBody =
          let guardExpr = com.TransformAsExpr(ctx, guard)
  