anchor.diff:          let body = [
                   if Option.isSome baseExpr then
                       yield callSuperAsStatement []
  -                yield! ent.FSharpFields |> Seq.mapi (fun i field ->
  +
  +                yield! (ent.FSharpFields |> List.collecti (fun i field ->
                       let left = get com ctx None thisExpr field.Name
                       let right = args.[i]
  -                    assign None left right |> exprAsStatement)
  -                |> Seq.toArray
  +                    assign None left right |> exprAsStatement ctx))
               ]
           let args = fieldIds |> Array.mapToList (ident com ctx >> Arg.arg)
           declareType com ctx ent entName args body baseExpr classMembers
  
positive.code:             let e, stmts = transformEmit com ctx range info
              if info.IsStatement then
                  stmts @ [ Statement.expr(e) ] // Ignore the return strategy
              else stmts @ [ resolveExpr t returnStrategy e ]
  
          | Fable.Operation(kind, t, range) ->
              let expr, stmts = transformOperation com ctx range kind
              stmts @ [ expr |> resolveExpr t returnStrategy ]
  
          | Fable.Get(expr, kind, t, range) ->
              let expr, stmts = transformGet com ctx range t expr kind
              stmts @ [ expr |> resolveExpr t returnStrategy ]
  
          | Fable.Let(ident, value, body) ->
              let binding = transformBindingAsStatements com ctx ident value
  
negative.code:             match kind with
              | Fable.Curry(e, arity) ->
                  let expr, stmts = transformCurry com ctx e arity
                  stmts @ (expr |> resolveExpr ctx e.Type returnStrategy)
              | Fable.Throw(TransformExpr com ctx (e, stmts), _) -> stmts @ [Statement.raise(e) ]
              | Fable.Return(TransformExpr com ctx (e, stmts)) -> stmts @ [ Statement.return'(e)]
              | Fable.Debugger -> []
  