Поддерживает ли композиция функции поддержки С#?

Ответ 1

Я не дал компилятору проверить это, но это должно быть возможно:

public static Func<T3,T1> my_chain<T1, T2, T3>(Func<T2,T1> f1, Func<T3,T2> f2)
{
    return x => f2(f1(x));
}

Ответ 2

public static class Extensions
{
    public static Func<T, TReturn2> Compose<T, TReturn1, TReturn2>(this Func<TReturn1, TReturn2> func1, Func<T, TReturn1> func2)
    {
        return x => func1(func2(x));
    }
}

Использование:

Func<int, int> makeDouble = x => x * 2;
Func<int, int> makeTriple = x => x * 3;
Func<int, string> toString = x => x.ToString();
Func<int, string> makeTimesSixString = toString.Compose(makeDouble).Compose(makeTriple);

//Prints "true"
Console.WriteLine(makeTimesSixString (3) == toString(makeDouble(makeTriple(3))));

Ответ 3

В С# нет конкретного оператора/ "синтаксического сахара" (однако в F # вы должны использовать оператор >>).

отличный пост в блоге по этому вопросу от Мэтью Подвицкого. Он предлагает такую ​​конструкцию в С#:

public static class FuncExtensions
{
    public static Func<TSource, TResult> ForwardCompose<TSource, TIntermediate, TResult>(
        this Func<TSource, TIntermediate> func1, Func<TIntermediate, TResult> func2)
    {
        return source => func2(func1(source));
    }
}

Func<Func<int, int>, IEnumerable<int>, IEnumerable<int>> map = (f, i) => i.Select(f);
Func<Func<int, bool>, IEnumerable<int>, IEnumerable<int>> filter = (f, i) => i.Where(f);
Func<int, Func<int, int, int>, IEnumerable<int>, int> fold = (s, f, i) => i.Aggregate(s, f);

// Compose together
var mapFilterFold = map.Apply(x => x * x * x)
    .ForwardCompose(filter.Apply(x => x % 3 == 0))
    .ForwardCompose(fold.Apply(1, (acc, x) => acc * x));
Console.WriteLine(mapFilterFold(Enumerable.Range(1, 10)));

Ответ 4

У С# нет поддержки первого класса, но это не особенно сложно реализовать. Вам просто нужно написать много перегрузок.

public static class Composition
{
    public static Func<T2> Compose<T1, T2>(Func<T1> f1, Func<T1, T2> f2)
    {
        return () => f2(f1());
    }

    public static Func<T1, T3> Compose<T1, T2, T3>(Func<T1, T2> f1, Func<T2, T3> f2)
    {
        return v => f2(f1(v));
    }
}

Ответ 5

Это не так красиво, но вы могли бы сделать:

Func<IEnumerable<T>, IEnumerable<T>> desort = l => l.OrderBy(i => i).Reverse();

Или, если вы хотите что-то более композитное-y (которое действует на массив на месте):

Action<int[]> desort = a => Array.Reverse(Array.Sort(a));

Предполагая, что эти методы существуют... но синтаксис должен быть прав.

Затем вы можете использовать его следующим образом (предполагая, что вы пошли первым методом выше):

var arr = { 2,8,7,10,1,9,5,3,4,6 };
var desortedArr = desort(arr);

Ответ 6

Больше, чем Linq, он делегирует и лямбда-выражения/инструкции, похожие на цепочку.

Func<int, string> a = p => p.ToString();
Func<string, string> b = p => "|" + p + "|";

Func<int, string> c = p => b(a(p));

Определение, приведенное в ссылке:

Состав функций - это акт конвейерной обработки результата одной функции на вход другой, создавая совершенно новую функцию.

И c - это, очевидно, новая функция, которая вызывает цепочку a и b.

Ответ 7

Нет, не нужно определять свои собственные общие функции Compose<T, U...>(). С# не имеет встроенных функций, которые помогут вам в этом. (Он также не выполняет частичное приложение.)

Ответ 8

Пример для композиции функций в С#

f (x) ° g (x)

Func<int, int> f = x => x + 2;
Func<int, int> g = x => 3 * x;

Func<int, int> b = x => f(g(x));

int result = b(2); //Result is 8