using System;

using System.Collections.Generic;

using System.Linq;

​

// ReSharper disable InconsistentNaming

​

namespace HighOrder

{

    public class Program

    {

        public static void Main(string[] args)

        {

            //Console.WriteLine(string.Format("{0:00}", 2+5.5555555));

​

            //fahrenheit to celsius

​

            var tempsInF = new List<int>{45,54,65,23,44,78,90,55 };

​

            Func<int, double> FahrenheitToCelsius = new Func<int, double>(x => x - 32).Compose(x => x*5.0/9.0);

​

            Func<int,double, double> average = (count,sum)=>sum/count;

            //var avg = average.Curry(); //avg(count)(sum)

​

            //What is the average temp in C* of all the temps over 50 F*?

            var results = tempsInF.Filter(x => x > 50).Map(FahrenheitToCelsius).Apply(x=> average(x.Count,x.Reduce((y, z) => y + z, 0.0)));

​

            Console.WriteLine(results);

        }

    }

​

    public static class HighOrder

    {

        public static X Head<X>(this List<X> list)

        {

            return list.First();

        }

​

        public static List<X> Tail<X>(this List<X> list)

        {

            return list.Skip(1).ToList();

        }

​

        public static Func<X, Z> Compose<X, Y, Z>(this Func<X, Y> f, Func<Y,Z> g)

        {

            return x => g(f(x));

        }

​

        public static List<T> Filter<T>(this List<T> list, Func<T, bool> predicate)

        {

            return list.Where(predicate).ToList();

        }

​

        public static List<Y> Map<X,Y>(this List<X> list, Func<X, Y> predicate)

        {

            return list.Select(predicate).ToList();

        }

​

        public static Y Apply<X, Y>(this X obj, Func<X, Y> function)

        {

            return function(obj);

        }

​

        public static Y Reduce<X, Y>(this List<X> list, Func<X, Y, Y> predicate, Y accumulator)

        {

            var current = accumulator;

            foreach (X element in list)

            {

                current = predicate(element, current);

            }

            return current;

        }

​

        public static Func<Y> Partial<X, Y>(this Func<X, Y> function, X arg)

        {

            return () => function(arg);

        }

        public static Func<Y, Z> Partial<X, Y, Z>(this Func<X, Y, Z> function, X arg1)

        {

            return arg2 => function(arg1, arg2);

        }

​

        //public static Func<Func<T, TResult>> Curry<T, TResult> (this Func<T, TResult> function) => () => arg => function(arg);

​

        //public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(this Func<T1, T2, TResult> function) => arg1 => arg2 => function(arg1, arg2);

    }

}

​