anchor.diff:          let name = Identifier("__init__")
           let self = Arg.arg("self")
           let args = Arguments.arguments (args = self::args)
  +        let body =
  +            match body with
  +            | [] -> [ Pass ]
  +            | _ -> body
  +
           FunctionDef.Create(name, args, body = body)
   
       let callFunction r funcExpr (args: Expression list) =
  
positive.code:         | Fable.NewArray (values, typ) -> makeArray com ctx values
          | Fable.NewArrayFrom (size, typ) ->
              let array, stmts = makeArray com ctx []
              Expression.binOp(array, Mult, Expression.constant(size)), stmts
          | Fable.NewTuple vals -> makeArray com ctx vals
          // Optimization for bundle size: compile list literals as List.ofArray
          | Fable.NewList (headAndTail, _) ->
  
negative.code:     // When expecting a block, it's usually not necessary to wrap it
      // in a lambda to isolate its variable context
      let transformBlock (com: IPythonCompiler) ctx ret expr: Statement list =
          let block =
              com.TransformAsStatements(ctx, ret, expr) |> List.choose Helpers.isProductiveStatement
          match block with
          | [] -> [ Pass ]
          | _ -> block
  
      let transformTryCatch com ctx r returnStrategy (body, (catch: option<Fable.Ident * Fable.Expr>), finalizer) =
          // try .. catch statements cannot be tail call optimized
  