anchor.diff:      let makeArrowFunctionExpression (args: Arguments) (body: Statement list) : Expression * Statement list =
           let args =
               match args.Args with
  -            | [] -> Arguments.arguments(args=[ Arg.arg(Python.Identifier("_unit")) ], defaults=[ Expression.none() ])
  +            | [] -> Arguments.arguments(args=[ Arg.arg(Identifier("_unit")) ], defaults=[ Expression.none() ])
               | _ -> args
   
           match body with
  
positive.code:         let stmt = Statement.classDef(name, body=classBody, bases=(baseExpr |> Option.toList) )
          Expression.call(Expression.name name), [ stmt ]
  
      let transformCallArgs (com: IPythonCompiler) ctx hasSpread args : Expression list * Statement list =
          match args with
          | []
          | [MaybeCasted(Fable.Value(Fable.UnitConstant,_))] -> [], []
          | args when hasSpread ->
              match List.rev args with
              | [] -> [], []
              | (Replacements.ArrayOrListLiteral(spreadArgs,_))::rest ->
                  let rest = List.rev rest |> List.map (fun e -> com.TransformAsExpr(ctx, e))
                  rest @ (List.map (fun e -> com.TransformAsExpr(ctx, e)) spreadArgs) |> Helpers.unzipArgs
              | last::rest ->
                  let rest, stmts = List.rev rest |> List.map (fun e -> com.TransformAsExpr(ctx, e)) |> Helpers.unzipArgs
                  let expr, stmts' = com.TransformAsExpr(ctx, last)
                  rest @ [ Expression.starred(expr) ], stmts @ stmts'
          | args -> List.map (fun e -> com.TransformAsExpr(ctx, e)) args |> Helpers.unzipArgs
  
      let resolveExpr (ctx: Context) t strategy pyExpr: Statement list =
          // printfn "resolveExpr: %A" (pyExpr, strategy)
  
negative.code:             Expression.call(consRef, values, ?loc=r), stmts @ stmts'
          | Fable.NewAnonymousRecord(values, fieldNames, _genArgs) ->
              let values, stmts = values |> List.map (fun x -> com.TransformAsExpr(ctx, x)) |> Helpers.unzipArgs
              List.zip (List.ofArray fieldNames) values |> makePyObject, stmts
          | Fable.NewUnion(values, tag, ent, genArgs) ->
              let ent = com.GetEntity(ent)
              let values, stmts = List.map (fun x -> com.TransformAsExpr(ctx, x)) values |> Helpers.unzipArgs
  