// 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;
			}

			public override bool Equals(object other)
			{
				if (other == null)
					return false;
				if (!(other is Tuple<T1, T2>))
					return false;
				var t = (Tuple<T1, T2>)other;				
				if (!EqualityComparer<T1>.Default.Equals(t.Value1, this.Value1))
					return false;
				if (!EqualityComparer<T2>.Default.Equals(t.Value2, this.Value2))
					return false;
				return true;
			}
			
			public override int GetHashCode()
			{
				unchecked
				{
					int hash = 983;
					hash = hash * 457 + base.GetHashCode();
					if (this.Value1 != null)
						hash = hash * 457 + this.Value1.GetHashCode();
					if (this.Value2 != null)
						hash = hash * 457 + this.Value2.GetHashCode();
					return hash;
				}
			}
		}

        /// <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;
			}

			public override bool Equals(object other)
			{
				if (other == null)
					return false;
				if (!(other is Tuple<T1, T2, T3>))
					return false;
				var t = (Tuple<T1, T2, T3>)other;				
				if (!EqualityComparer<T1>.Default.Equals(t.Value1, this.Value1))
					return false;
				if (!EqualityComparer<T2>.Default.Equals(t.Value2, this.Value2))
					return false;
				if (!EqualityComparer<T3>.Default.Equals(t.Value3, this.Value3))
					return false;
				return true;
			}
			
			public override int GetHashCode()
			{
				unchecked
				{
					int hash = 983;
					hash = hash * 457 + base.GetHashCode();
					if (this.Value1 != null)
						hash = hash * 457 + this.Value1.GetHashCode();
					if (this.Value2 != null)
						hash = hash * 457 + this.Value2.GetHashCode();
					if (this.Value3 != null)
						hash = hash * 457 + this.Value3.GetHashCode();
					return hash;
				}
			}
		}

        /// <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;
			}

			public override bool Equals(object other)
			{
				if (other == null)
					return false;
				if (!(other is Tuple<T1, T2, T3, T4>))
					return false;
				var t = (Tuple<T1, T2, T3, T4>)other;				
				if (!EqualityComparer<T1>.Default.Equals(t.Value1, this.Value1))
					return false;
				if (!EqualityComparer<T2>.Default.Equals(t.Value2, this.Value2))
					return false;
				if (!EqualityComparer<T3>.Default.Equals(t.Value3, this.Value3))
					return false;
				if (!EqualityComparer<T4>.Default.Equals(t.Value4, this.Value4))
					return false;
				return true;
			}
			
			public override int GetHashCode()
			{
				unchecked
				{
					int hash = 983;
					hash = hash * 457 + base.GetHashCode();
					if (this.Value1 != null)
						hash = hash * 457 + this.Value1.GetHashCode();
					if (this.Value2 != null)
						hash = hash * 457 + this.Value2.GetHashCode();
					if (this.Value3 != null)
						hash = hash * 457 + this.Value3.GetHashCode();
					if (this.Value4 != null)
						hash = hash * 457 + this.Value4.GetHashCode();
					return hash;
				}
			}
		}

        /// <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);
		}

	}
}