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

using System;
using System.Linq.Expressions;

namespace Developpez.Dotnet.Linq
{
    public static partial class LinqHelper
    {
        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </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 l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T1, T2, TResult>> Expr<T1, T2, TResult>(Expression<Func<T1, T2, TResult>> expr)
        {
            return expr;
        }
        
        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <param name="dummyArg1">Objet utilisé comme modèle pour déterminer le type du paramètre 1</param>
        /// <param name="dummyArg2">Objet utilisé comme modèle pour déterminer le type du paramètre 2</param>
        /// <typeparam name="TResult">Le type de retour de l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T1, T2, TResult>> Expr<T1, T2, TResult>(T1 dummyArg1, T2 dummyArg2, Expression<Func<T1, T2, TResult>> expr)
        {
            return expr;
        }

        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </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 l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T1, T2, T3, TResult>> Expr<T1, T2, T3, TResult>(Expression<Func<T1, T2, T3, TResult>> expr)
        {
            return expr;
        }
        
        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </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="dummyArg1">Objet utilisé comme modèle pour déterminer le type du paramètre 1</param>
        /// <param name="dummyArg2">Objet utilisé comme modèle pour déterminer le type du paramètre 2</param>
        /// <param name="dummyArg3">Objet utilisé comme modèle pour déterminer le type du paramètre 3</param>
        /// <typeparam name="TResult">Le type de retour de l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T1, T2, T3, TResult>> Expr<T1, T2, T3, TResult>(T1 dummyArg1, T2 dummyArg2, T3 dummyArg3, Expression<Func<T1, T2, T3, TResult>> expr)
        {
            return expr;
        }

        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </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 l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T1, T2, T3, T4, TResult>> Expr<T1, T2, T3, T4, TResult>(Expression<Func<T1, T2, T3, T4, TResult>> expr)
        {
            return expr;
        }
        
        /// <summary>
        /// Renvoie l'expression passée en paramètre, de façon à profiter de l'inférence de type
        /// </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="dummyArg1">Objet utilisé comme modèle pour déterminer le type du paramètre 1</param>
        /// <param name="dummyArg2">Objet utilisé comme modèle pour déterminer le type du paramètre 2</param>
        /// <param name="dummyArg3">Objet utilisé comme modèle pour déterminer le type du paramètre 3</param>
        /// <param name="dummyArg4">Objet utilisé comme modèle pour déterminer le type du paramètre 4</param>
        /// <typeparam name="TResult">Le type de retour de l'expression</typeparam>
        /// <param name="expr">L'expression dont on veut inférer le type</param>
        /// <returns>L'expression passée en paramètre</returns>
        public static Expression<Func<T1, T2, T3, T4, TResult>> Expr<T1, T2, T3, T4, TResult>(T1 dummyArg1, T2 dummyArg2, T3 dummyArg3, T4 dummyArg4, Expression<Func<T1, T2, T3, T4, TResult>> expr)
        {
            return expr;
        }


        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </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="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T1, T2, TResult> Func<T1, T2, TResult>(Func<T1, T2, TResult> func)
        {
            return func;
        }
        
        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </summary>
        /// <typeparam name="T1">Le type du paramètre 1</typeparam>
        /// <typeparam name="T2">Le type du paramètre 2</typeparam>
        /// <param name="dummyArg1">Objet utilisé comme modèle pour déterminer le type du paramètre 1</param>
        /// <param name="dummyArg2">Objet utilisé comme modèle pour déterminer le type du paramètre 2</param>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T1, T2, TResult> Func<T1, T2, TResult>(T1 dummyArg1, T2 dummyArg2, Func<T1, T2, TResult> func)
        {
            return func;
        }

        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </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="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T1, T2, T3, TResult> Func<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> func)
        {
            return func;
        }
        
        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </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="dummyArg1">Objet utilisé comme modèle pour déterminer le type du paramètre 1</param>
        /// <param name="dummyArg2">Objet utilisé comme modèle pour déterminer le type du paramètre 2</param>
        /// <param name="dummyArg3">Objet utilisé comme modèle pour déterminer le type du paramètre 3</param>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T1, T2, T3, TResult> Func<T1, T2, T3, TResult>(T1 dummyArg1, T2 dummyArg2, T3 dummyArg3, Func<T1, T2, T3, TResult> func)
        {
            return func;
        }

        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </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="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T1, T2, T3, T4, TResult> Func<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> func)
        {
            return func;
        }
        
        /// <summary>
        /// Renvoie la fonction passée en paramètre, de façon à profiter de l'inférence de type
        /// </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="dummyArg1">Objet utilisé comme modèle pour déterminer le type du paramètre 1</param>
        /// <param name="dummyArg2">Objet utilisé comme modèle pour déterminer le type du paramètre 2</param>
        /// <param name="dummyArg3">Objet utilisé comme modèle pour déterminer le type du paramètre 3</param>
        /// <param name="dummyArg4">Objet utilisé comme modèle pour déterminer le type du paramètre 4</param>
        /// <typeparam name="TResult">Le type de retour de la fonction</typeparam>
        /// <param name="func">La fonction dont on veut inférer le type</param>
        /// <returns>La fonction passée en paramètre</returns>
        public static Func<T1, T2, T3, T4, TResult> Func<T1, T2, T3, T4, TResult>(T1 dummyArg1, T2 dummyArg2, T3 dummyArg3, T4 dummyArg4, Func<T1, T2, T3, T4, TResult> func)
        {
            return func;
        }

    }
}