Есть ли основания использовать подобный подход?

#c_sharp #lambda

Заинтересовался конструкцией из JavaScript:
(function(){ /* code */ })();

решил попробовать реализовать подобное на C#:
public Func λ(Func f)
{
    return f;
}

Работать можно примерно следующим образом:
var i = λ((int x) => x*x + 2*x + 3)(5);// 38

var j = λ((string x) => x.Split(' '))("a bc def");// ["a", "bc", "def"]

хотелось бы услышать критику и/или идеи для развития подобной идеи.
UPD: теперь, когда функция называется λ (u03bb), а не  _  очень похоже на полноценное
лямбда-выражения, хоть и менее практично, осталось избавится от типа формального параметра,
у кого-нить есть идеи?


UPD2: ещё немного кодобреда:
исходя из определения логических операторов в λ-исчеслениях
true = λx. λy. x
false = λx. λy. y
not = λt. t false true

на С# получаем следующие
public Func True(T x)
{
    return λ((T y)=>x);
}

public Func False(T x)
{
    return λ((T y)=>y);
}

public Func> Not(Func>, Func>,
Func>>> t)
{
    return t(False)(True);
}

способ использования(ИСКЛЮЧИТЕЛЬНО в образовательных целях)
var true1 = λ((int x)=>λ((int y)=>x))(12)(21);// True 12

var true2 = True(12)(21);// 12

var false1 = False(12)(21);// 21

var false2 = Not(True)(12)(21);// 21
    

Ответы

Ответ 1

Вы просто играетесь с синтаксическим сахаром, который лежит за известным понятием
лямбда-функции.
Существует общеизвестная абстракция Func, которая являет собой некоторый функциональный
объект и может облагаться каким-либо контрактом в ходе выполнения. При этом выгода
λ-подобной записи достаточно сомнительна, поскольку разработчики уже привыкли к использованию
Func:
var t1 = new Func(s => s.Length)("X");
var t2 = λ(s => s.Length)("X");

Любая современная IDE после ввода var t = s => s.Length автоматически предложит вам
преобразовать лямбда-выражение в функциональный объект.

Короче, если подытожить, то вы просто переименовали new Func в λ. С таким же успехом,
например, можно переименовать Dictionary в D. Это, конечно, здорово, но не слишком полезно.


Ответ 2

Нижеизложенное в основном мое личное мнение.

Смысла функционального исчисления не в том, что функции анонимные или имеют какую
то особенную нотацию, а в том, что там нет переменных и состояний.

Из-за этого в нем приходится МУЧАТЬСЯ, из-за этого там придумали нотацию с т.н. лямбда-выражениями.

Все это потом выполняется на машинах Тьюринга, приспособленных для императивных языков,
в которых есть переменные и состояния.

В С# и другие языки добавили нотацию, но не добавили ограничения на отсутствие состояний.
Можно ведь в таких функциях переменные использовать и менять. 

То есть форма без сути. Мучения без выгоды.

Почему это стали делать? Похоже, что дело в образовании. В ВУЗах США массово внедрили
Java (не слушая профессоров). Несчастные преподаватели, понимающие, что обучение на
этом языке навсегда испортит студентам мышление и закроет возможность стать программистом
начали искать выход в замене его на функциональные языки. Например, тот самый Дейкстра,
который дожил до 2002 года, преподавал в Техасе и увидел наяву воплощение всех своих
худших кошмаров. Ну а дальше как обычно - чему в институте научили, то и тиражируют.
Теперь эти псевдолямбда выражения и псевдофункциональное программирование суют везде.
Причем форму, а не содержание.