Как красиво выбрать те элементы, которые НЕ являются буквами, не прибегая к лямбде

var letters = new char[] { 'a', '1', 'b', '2', 'c', '3', (char)1 }.Where(char.IsLetter);

var d = new char[] {'a', '1', 'b', '2', 'c', '3', (char) 1};
var list = new List<char>();
   foreach(var item in d)
       if (!char.IsLetter(item))
             list.Add(item);

var d = new char[] {'a', '1', 'b', '2', 'c', '3', (char) 1};
var list = d.Where(item => !char.IsLetter(item)).ToList();

var d = new char[] { 'a', '1', 'b', '2', 'c', '3', (char)1 };
var list = (from item in d where !char.IsLetter(item) select item).ToList();

static Func<TIn,bool> Not<TIn>(this Func<TIn,bool> func,TIn value)
{
    return a => !func(value);
}

public static class LinqExt
{
    public static IEnumerable<A> WhereNot<A>(this IEnumerable<A> xs, Func<A, bool> f)
    {
        return xs.Where(x => !f(x));
    }
}
//...............
var letters = new char[] { 'a', '1', 'b', '2', 'c', '3', (char)1 }.WhereNot(char.IsLetter);

class Predicate<T>
{
    Func<T, bool> val;
    public Func<T, bool> Value { get { return val ?? (t => false); } }
    public Predicate(Func<T, bool> predicate)
    {
        val = predicate;
    }
    public bool Not(T value)
    {
        return !val(value);
    }
}
 
var letters = new char[] { 'a', '1', 'b', '2', 'c', '3', (char)1 }
    .Where(new Predicate<char>(char.IsLetter).Not);

static Func<A,C> Chain<A, B, C>(Func<A, B> f, Func<B, C> g) { return (x) => g(f(x)); }
static Func<bool, bool> Not { get { return (x) => !x; } }
..... 
var letters = new char[] { 'a', '1', 'b', '2', 'c', '3', (char)1 }.Where(Chain(char.IsLetter, Not));

var letters = new char[] { 'a', '1', 'b', '2', 'c', '3', (char)1 }.Where(Chain<char, bool, bool>(char.IsLetter, Not));

var letters = new char[] { 'a', '1', 'b', '2', 'c', '3', (char)1 }.Where(_ => !char.IsLetter(_));

var letters = ("a1b2c3" + ((char)1)).Where(_ => !char.IsLetter(_));

Tuple<int,int> tuple = new Tuple<int,int>(1,2);

var tuple = new Tuple(1,2);