Why isn't it common to hack partial function application in C#?

Question

In many ways C# supports functional programming, but there is a (shrinking) list of features commonly found in statically-typed functional languages that are missing, such as tail recursion, partial function application, etc. Of these missing features, partial application is "fake-able" using existing language features, although it is a bit wordy.

For example,

public static class Program {

    public static Func<T2, TResult> PartialApply(
        this Func<T1, T2, TResult> function, T1 arg1) {

        return t2 => function(arg1, t2);
    }

    static void Main() {

        Func<int, int, int> add = (x, y) => x + y;

        var add10 = add.PartialApply(10);

        var sum = add10(3); //Result is 13
    }
}

This works, although lack of type inference on delegates makes it a bit wordy. However, I don't recall ever seeing source code where C# is used in this way. I was kind of surprised it was absent in Tomas Petricek's book, which goes over many ways to use C# like F#.

Is there a reason (other than convention) that no one is doing this?

---

If anyone is interested, here is I made a T4 template that can generate PartialApply -type functions for as many arguments as you need by just editing a number.

Answer 1

This works, although lack of type inference on delegates makes it a bit wordy.

This is basically it. Partial application is wonderful for making expressions involving higher-order functions more readable. For example

 list.Filter(IsResident("Florida")).Map(YearsResidedIn("UnitedStates")).Sum()

Would read pretty well. On the contrary

list.Filter(PartiallyApply((Func<String, Customer, bool>)IsResident, "Florida").Map(PartiallyApply((Func<String, Customer, int>)YearsResidedIn, "UnitedStates").Sum()

reads terribly, indeed much worse than

list.Filter(c => IsResident("Florida", c).Map(c => YearsResidedIn("UnitedStates", c)).Sum()

Furthermore in C# you have many delegate types. So in addition to the one you defined you would need

Func<T2, T3, TResult> PartiallyApply<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> func, T1 arg)
Func<T3, TResult> PartiallyApply<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> func, T1 arg1, T2 arg2)

Up to however many you can stomach to write plus a whole set of them for Action<>.

Basically, C# was really not designed for partial application. It does not feature the use of higher order functions nearly so heavily as a fully-fledged functional language, it has no inbuilt syntax partial application, it has a large set of delegate types that makes defining and using partial applications a pain, and even after you have defined your methods for partial application, you're going to have something more syntactically heavy and less readable than a plain old lambda expression.