using System;
using System.Diagnostics;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Linq;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        // Unfortunately type inference and method group conversion
        // aren't always happy together, so I've split them into
        // two statements.
        Func<int, int, int, string> function = SampleFunction;
        
        // Call the method directly
        string result1 = function(1, 2, 3);        
        Console.WriteLine("Result from normal call: {0}", result1);

        // 
        Func<int, int, string> partial = ApplyPartial(function, 1);
        string result2 = partial(2, 3);
        Console.WriteLine("Result from immediate partial application: {0}", result2);
        
        
        Func<int, int, string> partial1 = ApplyPartial(function, 1);
        Func<int, string> partial2 = ApplyPartial(partial1, 2);
        Func<string> partial3 = ApplyPartial(partial2, 3);
        string result3 = partial3();
        Console.WriteLine("Result from partial application in stages: {0}", result3);
                       
        // Call via currying
        Func<int, Func<int, Func<int, string>>> f1 = Curry(function);
        Func<int, Func<int, string>> f2 = f1(1);
        Func<int, string> f3 = f2(2);
        string result4 = f3(3);
        Console.WriteLine("Result from currying in stages: {0}", result4);
        
        // Or to do make all the calls together...
        var curried = Curry(function);
        string result5 = curried(1)(2)(3);
        Console.WriteLine("Result from currying in one go: {0}", result5);
    }

    static string SampleFunction(int a, int b, int c)
    {
        return string.Format("a={0}; b={1}; c={2}", a, b, c);
    }
    
    static Func<T2, T3, TResult> ApplyPartial<T1, T2, T3, TResult>
        (Func<T1, T2, T3, TResult> function, T1 arg1)
    {
        return (b, c) => function(arg1, b, c);
    }
    
    static Func<T2, TResult> ApplyPartial<T1, T2, TResult>
        (Func<T1, T2, TResult> function, T1 arg1)
    {
        return arg2 => function(arg1, arg2);
    }

    static Func<TResult> ApplyPartial<T1, TResult>
        (Func<T1, TResult> function, T1 arg1)
    {
        return () => function(arg1);
    }

    static Func<T1, Func<T2, Func<T3, TResult>>> Curry<T1, T2, T3, TResult>
        (Func<T1, T2, T3, TResult> function)
    {
        return a => b => c => function(a, b, c);
    }
}