// Attention : ce fichier a été automatiquement généré par un
// template T4. Toute modification manuelle sera écrasée !!!

using System;
using System.Collections.Generic;

namespace Developpez.Dotnet
{
    public static partial class FuncExtensions
    {
        private struct Tuple<T1, T2>
        {
            public readonly T1 Value1;
            public readonly T2 Value2;

            public Tuple(T1 value1, T2 value2)
            {
                this.Value1 = value1;
                this.Value2 = value2;
            }
        }

        /// <summary>
        /// Renvoie un wrapper de la fonction qui met en cache le résultat
        /// pour chaque ensemble de valeurs des arguments, de façon à n'appeler la fonction
        /// qu'une seule fois pour chaque ensemble de valeurs des arguments
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à mettre en cache</param>
        /// <returns>Une version de la fonction qui met en cache ses résultats</returns>
        public static Func<T1, T2, TResult> AsCached<T1, T2, TResult>(this Func<T1, T2, TResult> function)
        {
            var cachedResults = new Dictionary<Tuple<T1, T2>, TResult>();
            return (value1, value2) =>
            {
                TResult result;
                var paramsTuple = new Tuple<T1, T2>(value1, value2);
                lock(cachedResults)
                {
                    if (!cachedResults.TryGetValue(paramsTuple, out result))
                    {
                        result = function(value1, value2);
                        cachedResults.Add(paramsTuple, result);
                    }
                }
                return result;
            };
        }

        private struct Tuple<T1, T2, T3>
        {
            public readonly T1 Value1;
            public readonly T2 Value2;
            public readonly T3 Value3;

            public Tuple(T1 value1, T2 value2, T3 value3)
            {
                this.Value1 = value1;
                this.Value2 = value2;
                this.Value3 = value3;
            }
        }

        /// <summary>
        /// Renvoie un wrapper de la fonction qui met en cache le résultat
        /// pour chaque ensemble de valeurs des arguments, de façon à n'appeler la fonction
        /// qu'une seule fois pour chaque ensemble de valeurs des arguments
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à mettre en cache</param>
        /// <returns>Une version de la fonction qui met en cache ses résultats</returns>
        public static Func<T1, T2, T3, TResult> AsCached<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function)
        {
            var cachedResults = new Dictionary<Tuple<T1, T2, T3>, TResult>();
            return (value1, value2, value3) =>
            {
                TResult result;
                var paramsTuple = new Tuple<T1, T2, T3>(value1, value2, value3);
                lock(cachedResults)
                {
                    if (!cachedResults.TryGetValue(paramsTuple, out result))
                    {
                        result = function(value1, value2, value3);
                        cachedResults.Add(paramsTuple, result);
                    }
                }
                return result;
            };
        }

        private struct Tuple<T1, T2, T3, T4>
        {
            public readonly T1 Value1;
            public readonly T2 Value2;
            public readonly T3 Value3;
            public readonly T4 Value4;

            public Tuple(T1 value1, T2 value2, T3 value3, T4 value4)
            {
                this.Value1 = value1;
                this.Value2 = value2;
                this.Value3 = value3;
                this.Value4 = value4;
            }
        }

        /// <summary>
        /// Renvoie un wrapper de la fonction qui met en cache le résultat
        /// pour chaque ensemble de valeurs des arguments, de façon à n'appeler la fonction
        /// qu'une seule fois pour chaque ensemble de valeurs des arguments
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à mettre en cache</param>
        /// <returns>Une version de la fonction qui met en cache ses résultats</returns>
        public static Func<T1, T2, T3, T4, TResult> AsCached<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function)
        {
            var cachedResults = new Dictionary<Tuple<T1, T2, T3, T4>, TResult>();
            return (value1, value2, value3, value4) =>
            {
                TResult result;
                var paramsTuple = new Tuple<T1, T2, T3, T4>(value1, value2, value3, value4);
                lock(cachedResults)
                {
                    if (!cachedResults.TryGetValue(paramsTuple, out result))
                    {
                        result = function(value1, value2, value3, value4);
                        cachedResults.Add(paramsTuple, result);
                    }
                }
                return result;
            };
        }


        /// <summary>
        /// Renvoie une version curryfiée de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à curryfier</param>
        /// <returns>une version curryfiée de la fonction</returns>
        public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(this Func<T1, T2, TResult> function)
        {
            return arg1 => arg2 => function(arg1, arg2);
        }
        
        /// <summary>
        /// Renvoie une version curryfiée de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <param name="action">L'action à curryfier</param>
        /// <returns>une version curryfiée de l'action</returns>
        public static Func<T1, Action<T2>> Curry<T1, T2>(this Action<T1, T2> action)
        {
            return arg1 => arg2 => action(arg1, arg2);
        }

        /// <summary>
        /// Renvoie une version curryfiée de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à curryfier</param>
        /// <returns>une version curryfiée de la fonction</returns>
        public static Func<T1, Func<T2, Func<T3, TResult>>> Curry<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function)
        {
            return arg1 => arg2 => arg3 => function(arg1, arg2, arg3);
        }
        
        /// <summary>
        /// Renvoie une version curryfiée de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <param name="action">L'action à curryfier</param>
        /// <returns>une version curryfiée de l'action</returns>
        public static Func<T1, Func<T2, Action<T3>>> Curry<T1, T2, T3>(this Action<T1, T2, T3> action)
        {
            return arg1 => arg2 => arg3 => action(arg1, arg2, arg3);
        }

        /// <summary>
        /// Renvoie une version curryfiée de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à curryfier</param>
        /// <returns>une version curryfiée de la fonction</returns>
        public static Func<T1, Func<T2, Func<T3, Func<T4, TResult>>>> Curry<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function)
        {
            return arg1 => arg2 => arg3 => arg4 => function(arg1, arg2, arg3, arg4);
        }
        
        /// <summary>
        /// Renvoie une version curryfiée de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <param name="action">L'action à curryfier</param>
        /// <returns>une version curryfiée de l'action</returns>
        public static Func<T1, Func<T2, Func<T3, Action<T4>>>> Curry<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
        {
            return arg1 => arg2 => arg3 => arg4 => action(arg1, arg2, arg3, arg4);
        }


        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="firstArg">La valeur fixe pour le premier paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T2, TResult> ApplyFirst<T1, T2, TResult>(this Func<T1, T2, TResult> function, T1 firstArg)
        {
            return (secondArg) => function(firstArg, secondArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="firstArg">La valeur fixe pour le premier paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T2> ApplyFirst<T1, T2>(this Action<T1, T2> action, T1 firstArg)
        {
            return (secondArg) => action(firstArg, secondArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="secondArg">La valeur fixe pour le second paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T1, TResult> ApplySecond<T1, T2, TResult>(this Func<T1, T2, TResult> function, T2 secondArg)
        {
            return (firstArg) => function(firstArg, secondArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="secondArg">La valeur fixe pour le second paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T1> ApplySecond<T1, T2>(this Action<T1, T2> action, T2 secondArg)
        {
            return (firstArg) => action(firstArg, secondArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="firstArg">La valeur fixe pour le premier paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T2, T3, TResult> ApplyFirst<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function, T1 firstArg)
        {
            return (secondArg, thirdArg) => function(firstArg, secondArg, thirdArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="firstArg">La valeur fixe pour le premier paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T2, T3> ApplyFirst<T1, T2, T3>(this Action<T1, T2, T3> action, T1 firstArg)
        {
            return (secondArg, thirdArg) => action(firstArg, secondArg, thirdArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="secondArg">La valeur fixe pour le second paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T1, T3, TResult> ApplySecond<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function, T2 secondArg)
        {
            return (firstArg, thirdArg) => function(firstArg, secondArg, thirdArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="secondArg">La valeur fixe pour le second paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T1, T3> ApplySecond<T1, T2, T3>(this Action<T1, T2, T3> action, T2 secondArg)
        {
            return (firstArg, thirdArg) => action(firstArg, secondArg, thirdArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="thirdArg">La valeur fixe pour le troisième paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T1, T2, TResult> ApplyThird<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function, T3 thirdArg)
        {
            return (firstArg, secondArg) => function(firstArg, secondArg, thirdArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="thirdArg">La valeur fixe pour le troisième paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T1, T2> ApplyThird<T1, T2, T3>(this Action<T1, T2, T3> action, T3 thirdArg)
        {
            return (firstArg, secondArg) => action(firstArg, secondArg, thirdArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="firstArg">La valeur fixe pour le premier paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T2, T3, T4, TResult> ApplyFirst<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, T1 firstArg)
        {
            return (secondArg, thirdArg, fourthArg) => function(firstArg, secondArg, thirdArg, fourthArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="firstArg">La valeur fixe pour le premier paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T2, T3, T4> ApplyFirst<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T1 firstArg)
        {
            return (secondArg, thirdArg, fourthArg) => action(firstArg, secondArg, thirdArg, fourthArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="secondArg">La valeur fixe pour le second paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T1, T3, T4, TResult> ApplySecond<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, T2 secondArg)
        {
            return (firstArg, thirdArg, fourthArg) => function(firstArg, secondArg, thirdArg, fourthArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="secondArg">La valeur fixe pour le second paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T1, T3, T4> ApplySecond<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T2 secondArg)
        {
            return (firstArg, thirdArg, fourthArg) => action(firstArg, secondArg, thirdArg, fourthArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="thirdArg">La valeur fixe pour le troisième paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T1, T2, T4, TResult> ApplyThird<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, T3 thirdArg)
        {
            return (firstArg, secondArg, fourthArg) => function(firstArg, secondArg, thirdArg, fourthArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="thirdArg">La valeur fixe pour le troisième paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T1, T2, T4> ApplyThird<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T3 thirdArg)
        {
            return (firstArg, secondArg, fourthArg) => action(firstArg, secondArg, thirdArg, fourthArg);
        }

        /// <summary>
        /// Renvoie une application partielle de la fonction
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="function">La fonction à appliquer partiellement</param>
        /// <param name="fourthArg">La valeur fixe pour le quatrième paramètre de la fonction</param>
        /// <returns>une application partielle de la fonction</returns>
        public static Func<T1, T2, T3, TResult> ApplyFourth<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function, T4 fourthArg)
        {
            return (firstArg, secondArg, thirdArg) => function(firstArg, secondArg, thirdArg, fourthArg);
        }
        
        /// <summary>
        /// Renvoie une application partielle de l'action
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <typeparam name="T3">Le type du paramètre 3</typeparam>
        /// <typeparam name="T4">Le type du paramètre 4</typeparam>
        /// <param name="action">L'action à appliquer partiellement</param>
        /// <param name="fourthArg">La valeur fixe pour le quatrième paramètre de l'action</param>
        /// <returns>une application partielle de l'action</returns>
        public static Action<T1, T2, T3> ApplyFourth<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action, T4 fourthArg)
        {
            return (firstArg, secondArg, thirdArg) => action(firstArg, secondArg, thirdArg, fourthArg);
        }


    }
}