Estou tentando criar uma implementação paraNotOfType, que possui uma sintaxe de chamada legível.NotOfType deve ser o complemento paraOfType<T> e, consequentemente, produziria todos os elementos que sãonão do tipoT

Meu objetivo era implementar um método que seria chamado comoOfType<T>, como na última linha deste snippet:

public abstract class Animal {}
public class Monkey : Animal {}
public class Giraffe : Animal {}
public class Lion : Animal {}

var monkey = new Monkey();
var giraffe = new Giraffe();
var lion = new Lion();

IEnumerable<Animal> animals = new Animal[] { monkey, giraffe, lion };

IEnumerable<Animal> fewerAnimals = animals.NotOfType<Giraffe>();

No entanto, não consigo criar uma implementação que suporte essa sintaxe de chamada específica.

Isto é o que eu tentei até agora:

public static class EnumerableExtensions
{
    public static IEnumerable<T> NotOfType<T>(this IEnumerable<T> sequence, Type type)
    {
        return sequence.Where(x => x.GetType() != type);
    }

    public static IEnumerable<T> NotOfType<T, TExclude>(this IEnumerable<T> sequence)
    {
        return sequence.Where(x => !(x is TExclude));
    }
}

Chamar esses métodos ficaria assim:

// Animal is inferred
IEnumerable<Animal> fewerAnimals = animals.NotOfType(typeof(Giraffe));

e

// Not all types could be inferred, so I have to state all types explicitly
IEnumerable<Animal> fewerAnimals = animals.NotOfType<Animal, Giraffe>();

Penso que existem grandes desvantagens no estilo de ambas as chamadas. O primeiro sofre um redundante "do tipo / tipo de" construto, e o segundo simplesmente não faz sentido (quero uma lista de animais que não são nem Animais nem Girafas?).

Então, existe uma maneira de realizar o que eu quero? Caso contrário, seria possível em versões futuras do idioma? (Estou pensando que talvez um dia tenhamos nomeado argumentos de tipo ou que apenas precisamos fornecer explicitamente argumentos de tipo que não podem ser inferidos?)

Ou estou apenas sendo bobo?