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. 
Why isn't it common to hack partial function application in C#?
c#;functional programming
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 contrarylist.Filter(PartiallyApply((Func<String, Customer, bool>)IsResident, Florida).Map(PartiallyApply((Func<String, Customer, int>)YearsResidedIn, UnitedStates).Sum()reads terribly, indeed much worse thanlist.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 needFunc<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.