using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Developpez.Dotnet.Linq;
using Developpez.Dotnet.Properties;

namespace Developpez.Dotnet.Collections
{
    public static partial class EnumerableExtensions
    {
        #region IsNullOrEmpty

        /// <summary>
        /// Indique si une collection est nulle ou vide
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la collection</typeparam>
        /// <param name="collection">La collection à tester</param>
        /// <returns>true si la collection est nulle ou vide, false sinon</returns>
        public static bool IsNullOrEmpty<TSource>(this IEnumerable<TSource> collection)
        {
            if (collection == null)
                return true;
            return !collection.Any();
        }

        /// <summary>
        /// Indique si une collection est nulle ou vide
        /// </summary>
        /// <param name="collection">La collection à tester</param>
        /// <returns>true si la collection est nulle ou vide, false sinon</returns>
        public static bool IsNullOrEmpty(this IEnumerable collection)
        {
            if (collection == null)
                return true;
            var collection2 = collection as ICollection;
            if (collection2 != null)
                return collection2.Count == 0;
            var enumerator = collection.GetEnumerator();
            return !enumerator.MoveNext();
        }

        #endregion

        #region Zip

        // Contournement d'un bug dans Resharper: la directive #if entre le commentaire de doc et la
        // méthode provoque ces deux avertissements (mais le comportement du compilateur est correct)
#pragma warning disable 1587
#pragma warning disable 1591
        /// <summary>
        /// Fusionne 2 séquences selon la fonction de projection spécifiée, en faisant correspondre
        /// chaque élément de la première séquence à l'élément de même index dans la deuxième séquence.
        /// </summary>
        /// <typeparam name="TFirst">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TSecond">Type des éléments de la deuxième séquence</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence fusionnée</typeparam>
        /// <param name="first">première séquence</param>
        /// <param name="second">deuxième séquence</param>
        /// <param name="selector">fonction de projection pour fusionner des éléments des 2 séquences</param>
        /// <returns>Une séquence d'éléments fusionnée</returns>
        /// <remarks>
        /// <para>Si les 2 séquences ne sont pas de même longueur, les éléments surnuméraires de la séquence la plus longue sont ignorés.</para>
        /// <note>Cette méthode est absente de la version compilée pour .NET 4, car elle est déjà définie dans le framework 4.0 (Enumerable.Zip)</note>
        /// </remarks>

        // La méthode Zip a été ajoutée dans .NET 4.0 et ne sera donc plus nécessaire
        // Par contre elle est utilisée en interne et doit donc rester présente
#if DOTNET4
        internal
#else
        public
#endif
 static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> selector)
        {
            first.CheckArgumentNull("first");
            second.CheckArgumentNull("second");
            selector.CheckArgumentNull("selector");

            return first.ZipIterator(second, selector);
        }
#pragma warning restore 1591
#pragma warning restore 1587


        private static IEnumerable<TResult> ZipIterator<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> selector)
        {
            using (var enum1 = first.GetEnumerator())
            using (var enum2 = second.GetEnumerator())
            {
                while (enum1.MoveNext() && enum2.MoveNext())
                {
                    yield return selector(enum1.Current, enum2.Current);
                }
            }
        }

        #endregion

        #region Append, Prepend

        /// <summary>
        /// Ajoute un élément à la suite de la séquence spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'origine</param>
        /// <param name="item">Elément à ajouter</param>
        /// <returns>La séquence d'origine suivie de l'élément spécifiée</returns>
        public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource item)
        {
            return source.Concat(new[] { item });
        }

        /// <summary>
        /// Insère un élément au début de la séquence spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'origine</param>
        /// <param name="item">Elément à insérer</param>
        /// <returns>La séquence d'origine précédée de l'élément spécifiée</returns>
        public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource item)
        {
            return new[] { item }.Concat(source);
        }

        #endregion

        #region IsOrdered and related methods

        /// <summary>
        /// Vérifie que la liste est triée, en utilisant le comparateur spécifié
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <param name="comparer">Le comparateur à utiliser</param>
        /// <returns>true si la liste est triée, false sinon</returns>
        public static bool IsOrdered<TSource>(this IEnumerable<TSource> list, IComparer<TSource> comparer)
        {
            return list.IsOrdered(comparer.ToComparison());
        }

        /// <summary>
        /// Vérifie que la liste est triée, en utilisant la comparaison spécifiée
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <param name="comparison">La comparaison à utiliser</param>
        /// <returns>true si la liste est triée, false sinon</returns>
        public static bool IsOrdered<TSource>(this IEnumerable<TSource> list, Comparison<TSource> comparison)
        {
            bool isFirstPass = true;
            TSource previous = default(TSource);
            foreach (TSource item in list)
            {
                if (!isFirstPass)
                {
                    if (comparison(previous, item) > 0)
                        return false;
                }
                isFirstPass = false;
                previous = item;
            }
            return true;
        }

        /// <summary>
        /// Vérifie que la liste est triée, en utilisant le comparateur par défaut
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <returns>true si la liste est triée, false sinon</returns>
        public static bool IsOrdered<TSource>(this IEnumerable<TSource> list)
        {
            return list.IsOrdered(Comparer<TSource>.Default);
        }

        /// <summary>
        /// Vérifie que la liste est triée en ordre descendant, en utilisant le comparateur spécifié
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <param name="comparer">Le comparateur à utiliser</param>
        /// <returns>true si la liste est triée, false sinon</returns>
        public static bool IsOrderedDescending<TSource>(this IEnumerable<TSource> list, IComparer<TSource> comparer)
        {
            return list.IsOrdered(comparer.Reverse());
        }

        /// <summary>
        /// Vérifie que la liste est triée en ordre descendant, en utilisant le comparateur par défaut
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <returns>true si la liste est triée, false sinon</returns>
        public static bool IsOrderedDescending<TSource>(this IEnumerable<TSource> list)
        {
            return list.IsOrdered(Comparer<TSource>.Default.Reverse());
        }

        /// <summary>
        /// Vérifie que la liste est triée selon la clé de tri spécifiée, en utilisant le comparateur spécifié
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <typeparam name="TKey">Le type de la clé de tri</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <param name="comparer">Le comparateur à utiliser</param>
        /// <param name="keySelector">Une fonction pour extraire la clé de tri de l'élément</param>
        /// <returns>true si la liste est triée selon le critère spécifié, false sinon</returns>
        public static bool IsOrderedBy<TSource, TKey>(this IEnumerable<TSource> list, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            return list.Select(keySelector).IsOrdered(comparer);
        }

        /// <summary>
        /// Vérifie que la liste est triée selon la clé de tri spécifiée, en utilisant le comparateur par défaut
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <typeparam name="TKey">Le type de la clé de tri</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <param name="keySelector">Une fonction pour extraire la clé de tri de l'élément</param>
        /// <returns>true si la liste est triée selon le critère spécifié, false sinon</returns>
        public static bool IsOrderedBy<TSource, TKey>(this IEnumerable<TSource> list, Func<TSource, TKey> keySelector)
        {
            return list.IsOrderedBy(keySelector, Comparer<TKey>.Default);
        }

        /// <summary>
        /// Vérifie que la liste est triée en ordre descendant selon la clé de tri spécifiée, en utilisant le comparateur spécifié
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <typeparam name="TKey">Le type de la clé de tri</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <param name="comparer">Le comparateur à utiliser</param>
        /// <param name="keySelector">Une fonction pour extraire la clé de tri de l'élément</param>
        /// <returns>true si la liste est triée selon le critère spécifié, false sinon</returns>
        public static bool IsOrderedByDescending<TSource, TKey>(this IEnumerable<TSource> list, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            return list.IsOrderedBy(keySelector, comparer.Reverse());
        }

        /// <summary>
        /// Vérifie que la liste est triée en ordre descendant selon la clé de tri spécifiée, en utilisant le comparateur par défaut
        /// </summary>
        /// <typeparam name="TSource">Le type des éléments de la liste</typeparam>
        /// <typeparam name="TKey">Le type de la clé de tri</typeparam>
        /// <param name="list">La liste à vérifier</param>
        /// <param name="keySelector">Une fonction pour extraire la clé de tri de l'élément</param>
        /// <returns>true si la liste est triée selon le critère spécifié, false sinon</returns>
        public static bool IsOrderedByDescending<TSource, TKey>(this IEnumerable<TSource> list, Func<TSource, TKey> keySelector)
        {
            return list.IsOrderedBy(keySelector, Comparer<TKey>.Default.Reverse());
        }

        #endregion

        #region AggregateByPairs

        /// <summary>
        /// Applique une fonction d'accumulation sur une séquence, en prenant les
        /// éléments consécutifs 2 par 2. La valeur spécifiée pour <c>seed</c> est
        /// utilisée comme valeur initiale de l'accumulateur.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TAccumulate">Type de l'accumulateur</typeparam>
        /// <param name="source">Séquence sur laquelle appliquer l'accumulation</param>
        /// <param name="seed">Valeur initiale de l'accumulateur</param>
        /// <param name="func">Fonction d'accumulation</param>
        /// <returns>La valeur finale de l'accumulateur</returns>
        /// <remarks>La fonction d'accumulation prend en paramètres, dans cet ordre:
        /// la valeur courante de l'accumulateur, l'élément courant et l'élément précédent.</remarks>
        public static TAccumulate AggregateByPairs<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            TAccumulate seed,
            Func<TAccumulate, TSource, TSource, TAccumulate> func)
        {
            return AggregateByPairs(source, seed, func, LinqHelper.Identity);
        }

        /// <summary>
        /// Applique une fonction d'accumulation sur une séquence, en prenant les
        /// éléments consécutifs 2 par 2. La valeur spécifiée pour <c>seed</c> est
        /// utilisée comme valeur initiale de l'accumulateur, et la fonction spécifiée
        /// est utilisée pour sélectionner le résultat final
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TAccumulate">Type de l'accumulateur</typeparam>
        /// <typeparam name="TResult">Type du résultat final</typeparam>
        /// <param name="source">Séquence sur laquelle appliquer l'accumulation</param>
        /// <param name="seed">Valeur initiale de l'accumulateur</param>
        /// <param name="func">Fonction d'accumulation</param>
        /// <param name="resultSelector">Fonction qui transforme la valeur finale de l'accumulateur en le résultat final</param>
        /// <returns>La valeur finale de l'accumulateur transformée par <c>resultSelector</c></returns>
        /// <remarks>La fonction d'accumulation prend en paramètres, dans cet ordre:
        /// la valeur courante de l'accumulateur, l'élément courant et l'élément précédent.</remarks>
        public static TResult AggregateByPairs<TSource, TAccumulate, TResult>(
            this IEnumerable<TSource> source,
            TAccumulate seed,
            Func<TAccumulate, TSource, TSource, TAccumulate> func,
            Func<TAccumulate, TResult> resultSelector)
        {
            TAccumulate acc = seed;
            TSource prev = default(TSource);
            bool first = true;
            foreach (var item in source)
            {
                if (!first)
                    acc = func(acc, item, prev);
                first = false;
                prev = item;
            }
            return resultSelector(acc);
        }

        #endregion

        #region SelectAggregate

        // TODO: nom à revoir (Scan ?)

        /// <summary>
        /// Applique une fonction d'accumulation sur une séquence, en renvoyant la valeur
        /// de l'accumulateur à chaque étape.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de <c>source</c></typeparam>
        /// <typeparam name="TAccumulate">Type de l'accumulateur</typeparam>
        /// <param name="source">Séquence sur laquelle appliquer l'accumulation</param>
        /// <param name="seed">Valeur initiale de l'accumulateur</param>
        /// <param name="func">Fonction d'accumulation à appeler sur chaque élément</param>
        /// <returns>Séquence des valeurs de l'accumulateur à chaque étape.</returns>
        /// <remarks>Cette méthode est similaire à Enumerable.Aggregate, mais cette dernière ne renvoie que le résultat
        /// final, alors que SelectAggregate renvoie le résultat de chaque étape.</remarks>
        public static IEnumerable<TAccumulate> SelectAggregate<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            TAccumulate seed,
            Func<TAccumulate, TSource, TAccumulate> func)
        {
            source.CheckArgumentNull("source");
            func.CheckArgumentNull("func");
            return source.SelectAggregateIterator(seed, func);
        }

        private static IEnumerable<TAccumulate> SelectAggregateIterator<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            TAccumulate seed,
            Func<TAccumulate, TSource, TAccumulate> func)
        {
            TAccumulate previous = seed;
            foreach (var item in source)
            {
                TAccumulate result = func(previous, item);
                previous = result;
                yield return result;
            }
        }

        /// <summary>
        /// Applique une fonction d'accumulation sur une séquence, en renvoyant
        /// la valeur de l'accumulateur à chaque étape.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de <c>source</c></typeparam>
        /// <typeparam name="TAccumulate">Type de l'accumulateur</typeparam>
        /// <param name="source">Séquence sur laquelle appliquer l'accumulation</param>
        /// <param name="func">Fonction d'accumulation à appeler sur chaque élément</param>
        /// <returns>Séquence des valeurs de l'accumulateur à chaque étape.</returns>
        /// <remarks>Cette méthode est similaire à Enumerable.Aggregate, mais cette dernière ne renvoie que le résultat
        /// final, alors que SelectAggregate renvoie le résultat de chaque étape.</remarks>
        public static IEnumerable<TAccumulate> SelectAggregate<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            Func<TAccumulate, TSource, TAccumulate> func)
        {
            return source.SelectAggregate(default(TAccumulate), func);
        }

        /// <summary>
        /// Applique une fonction d'accumulation sur une séquence, en renvoyant
        /// la valeur de l'accumulateur à chaque étape. La fonction d'accumulation
        /// prend en paramètre les 2 valeurs précédentes de l'accumulateur.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de <c>source</c></typeparam>
        /// <typeparam name="TAccumulate">Type de l'accumulateur</typeparam>
        /// <param name="source">Séquence sur laquelle appliquer l'accumulation</param>
        /// <param name="seed1">Valeur initiale de l'accumulateur (itération n-1)</param>
        /// <param name="seed2">Valeur initiale de l'accumulateur (itération n-2)</param>
        /// <param name="func">Fonction d'accumulation à appeler sur chaque élément</param>
        /// <returns>Séquence des valeurs de l'accumulateur à chaque étape.</returns>
        public static IEnumerable<TAccumulate> SelectAggregate<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            TAccumulate seed1,
            TAccumulate seed2,
            Func<TAccumulate, TAccumulate, TSource, TAccumulate> func)
        {
            source.CheckArgumentNull("source");
            func.CheckArgumentNull("func");
            return source.SelectAggregateIterator(seed1, seed2, func);
        }

        private static IEnumerable<TAccumulate> SelectAggregateIterator<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            TAccumulate seed1,
            TAccumulate seed2,
            Func<TAccumulate, TAccumulate, TSource, TAccumulate> func)
        {
            TAccumulate previous1 = seed1;
            TAccumulate previous2 = seed2;
            foreach (var item in source)
            {
                TAccumulate result = func(previous1, previous2, item);
                previous2 = previous1;
                previous1 = result;
                yield return result;
            }
        }

        /// <summary>
        /// Applique une fonction d'accumulation sur une séquence, en renvoyant
        /// la valeur de l'accumulateur à chaque étape. La fonction d'accumulation
        /// prend en paramètre les 2 valeurs précédentes de l'accumulateur.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de <c>source</c></typeparam>
        /// <typeparam name="TAccumulate">Type de l'accumulateur</typeparam>
        /// <param name="source">Séquence sur laquelle appliquer l'accumulation</param>
        /// <param name="func">Fonction d'accumulation à appeler sur chaque élément</param>
        /// <returns>Séquence des valeurs de l'accumulateur à chaque étape.</returns>
        public static IEnumerable<TAccumulate> SelectAggregate<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            Func<TAccumulate, TAccumulate, TSource, TAccumulate> func)
        {
            return source.SelectAggregate(default(TAccumulate), default(TAccumulate), func);
        }

        #endregion

        #region FirstOrDefault, LastOrDefault, ElementAtOrDefault, SingleOrDefault

        /// <summary>
        /// Retourne le premier élément d'une séquence, ou la valeur par défaut spécifiée si la séquence ne contient aucun élément.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de source</typeparam>
        /// <param name="source">Séquence à partir de laquelle retourner le premier élément</param>
        /// <param name="defaultValue">La valeur par défaut à renvoyer si la séquence est vide</param>
        /// <returns>Le premier élément de source s'il existe, sinon la valeur par défaut spécifiée</returns>
        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
        {
            return source.DefaultIfEmpty(defaultValue).First();
        }

        /// <summary>
        /// Retourne le premier élément de la séquence à satisfaire à une condition, ou la valeur par défaut spécifiée
        /// si aucun élément correspondant n'est trouvé.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de source</typeparam>
        /// <param name="source">Séquence à partir de laquelle retourner un élément</param>
        /// <param name="predicate">Condition à vérifier</param>
        /// <param name="defaultValue">La valeur par défaut à renvoyer si aucun élément ne satisfait la condition</param>
        /// <returns>Le premier élément de source à satisfaire la condition, ou la valeur par défaut spécifiée si aucun
        /// élément ne satisfait la condition</returns>
        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue)
        {
            return source.Where(predicate).FirstOrDefault(defaultValue);
        }

        /// <summary>
        /// Retourne le dernier élément d'une séquence, ou la valeur par défaut spécifiée si la séquence ne contient aucun élément.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de source</typeparam>
        /// <param name="source">Séquence à partir de laquelle retourner le dernier élément</param>
        /// <param name="defaultValue">La valeur par défaut à renvoyer si la séquence est vide</param>
        /// <returns>Le dernier élément de source s'il existe, sinon la valeur par défaut spécifiée</returns>
        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
        {
            return source.DefaultIfEmpty(defaultValue).Last();
        }

        /// <summary>
        /// Retourne le dernier élément de la séquence à satisfaire à une condition, ou la valeur par défaut spécifiée
        /// si aucun élément correspondant n'est trouvé.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de source</typeparam>
        /// <param name="source">Séquence à partir de laquelle retourner un élément</param>
        /// <param name="predicate">Condition à vérifier</param>
        /// <param name="defaultValue">La valeur par défaut à renvoyer si aucun élément ne satisfait la condition</param>
        /// <returns>Le dernier élément de source à satisfaire la condition, ou la valeur par défaut spécifiée si aucun
        /// élément ne satisfait la condition</returns>
        public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue)
        {
            return source.Where(predicate).LastOrDefault(defaultValue);
        }

        /// <summary>
        /// Retourne l'élément situé à un index spécifié dans une séquence, ou la valeur par défaut spécifiée si l'index est hors limites.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de source</typeparam>
        /// <param name="source">Séquence à partir de laquelle retourner un élément</param>
        /// <param name="index">Index de l'élément à récupérer</param>
        /// <param name="defaultValue">Valeur par défaut à renvoyer si l'index est hors-limite</param>
        /// <returns>L'élément à l'index spécifié s'il existe ; sinon, la valeur par défaut spécifiée.</returns>
        public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> source, int index, TSource defaultValue)
        {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index");

            return source.Skip(index).DefaultIfEmpty(defaultValue).First();
        }

        /// <summary>
        /// Retourne l'unique élément d'une séquence, ou la valeur par défaut spécifiée si la séquence n'a aucun élément.
        /// Lève une exception si la séquence contient plus d'un élément
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de source</typeparam>
        /// <param name="source">Séquence à partir de laquelle retourner un élément</param>
        /// <param name="defaultValue">Valeur par défaut à retourner si la séquence est vide</param>
        /// <returns>L'unique élément de la séquence, ou la valeur par défaut spécifiée si la séquence est vide</returns>
        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
        {
            int i = 0;
            TSource value = defaultValue;
            foreach (var item in source)
            {
                if (i == 0)
                {
                    value = item;
                }
                else
                {
                    throw new InvalidOperationException(ExceptionMessages.InputSequenceHasMoreThanOneElement);
                }
                i++;
            }
            return value;
        }

        /// <summary>
        /// Retourne l'unique élément d'une séquence qui satisfait une condition, ou la valeur par défaut
        /// spécifiée si aucun élément ne satisfait la condition.
        /// Lève une exception si plusieurs éléments satisfont la condition.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de source</typeparam>
        /// <param name="source">Séquence à partir de laquelle retourner un élément</param>
        /// <param name="predicate">La condition à vérifier</param>
        /// <param name="defaultValue">Valeur par défaut à retourner si aucun élément ne satisfait la condition</param>
        /// <returns>L'unique élément de la séquence, ou la valeur par défaut spécifiée si aucun élément ne satisfait la condition</returns>
        public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, TSource defaultValue)
        {
            return source.Where(predicate).SingleOrDefault(defaultValue);
        }

        #endregion

        #region MaxBy, MinBy

        private static void ThrowEmptySequence()
        {
            throw new InvalidOperationException(ExceptionMessages.SequenceContainsNoElements);
        }

        /// <summary>
        /// Renvoie l'élément de la séquence ayant la plus grande valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <returns>L'élément ayant la plus grande valeur pour la fonction spécifiée</returns>
        public static TSource MaxBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.ExtremeBy(selector, null, 1);
        }

        /// <summary>
        /// Renvoie l'élément de la séquence ayant la plus grande valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <param name="comparer">Comparateur à utiliser pour le résultat du sélecteur. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>L'élément ayant la plus grande valeur pour la fonction spécifiée</returns>
        public static TSource MaxBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IComparer<TKey> comparer)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.ExtremeBy(selector, comparer, 1);
        }

        /// <summary>
        /// Renvoie l'élément de la séquence ayant la plus petite valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <returns>L'élément ayant la plus petite valeur pour la fonction spécifiée</returns>
        public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.ExtremeBy(selector, null, -1);
        }

        /// <summary>
        /// Renvoie l'élément de la séquence ayant la plus petite valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <param name="comparer">Comparateur à utiliser pour le résultat du sélecteur. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>L'élément ayant la plus petite valeur pour la fonction spécifiée</returns>
        public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IComparer<TKey> comparer)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.ExtremeBy(selector, comparer, -1);
        }

        private static TSource ExtremeBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IComparer<TKey> comparer, int sign)
        {
            comparer = comparer ?? Comparer<TKey>.Default;
            TKey extremeValue = default(TKey);
            TSource extreme = default(TSource);
            bool first = true;
            foreach (var item in source)
            {
                TKey value = selector(item);
                int compare = comparer.Compare(value, extremeValue);

                if (Math.Sign(compare) == sign || first)
                {
                    extremeValue = value;
                    extreme = item;
                }
                first = false;
            }
            if (first)
                ThrowEmptySequence();

            return extreme;
        }

        /// <summary>
        /// Renvoie tous les éléments de la séquence ayant la plus grande valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <returns>Collection des éléments ayant la plus grande valeur pour la fonction spécifiée</returns>
        public static IEnumerable<TSource> AllMaxBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.AllExtremesBy(selector, null, 1);
        }

        /// <summary>
        /// Renvoie tous les éléments de la séquence ayant la plus grande valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <param name="comparer">Comparateur à utiliser pour le résultat du sélecteur. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Collection des éléments ayant la plus grande valeur pour la fonction spécifiée</returns>
        public static IEnumerable<TSource> AllMaxBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IComparer<TKey> comparer)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.AllExtremesBy(selector, comparer, 1);
        }

        /// <summary>
        /// Renvoie tous les éléments de la séquence ayant la plus petite valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <returns>Collection des éléments ayant la plus petite valeur pour la fonction spécifiée</returns>
        public static IEnumerable<TSource> AllMinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.AllExtremesBy(selector, null, -1);
        }

        /// <summary>
        /// Renvoie tous les éléments de la séquence ayant la plus petite valeur pour la fonction spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de retour de la fonction à évaluer</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="selector">Fonction évaluée pour chaque élément</param>
        /// <param name="comparer">Comparateur à utiliser pour le résultat du sélecteur. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Collection des éléments la plus petite valeur pour la fonction spécifiée</returns>
        public static IEnumerable<TSource> AllMinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IComparer<TKey> comparer)
        {
            source.CheckArgumentNull("source");
            selector.CheckArgumentNull("selector");
            return source.AllExtremesBy(selector, comparer, -1);
        }

        private static IEnumerable<TSource> AllExtremesBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IComparer<TKey> comparer, int sign)
        {
            comparer = comparer ?? Comparer<TKey>.Default;
            TKey extremeValue = default(TKey);
            List<TSource> extremes = new List<TSource>();
            bool first = true;
            foreach (var item in source)
            {
                TKey value = selector(item);
                int compare = comparer.Compare(value, extremeValue);

                if (first)
                {
                    extremeValue = value;
                    extremes.Add(item);
                }
                else if (Math.Sign(compare) == sign)
                {
                    extremes.Clear();
                    extremeValue = value;
                    extremes.Add(item);
                }
                else if (compare == 0)
                {
                    extremes.Add(item);
                }
                first = false;
            }
            return extremes.ToArray();
        }

        #endregion

        #region Max, Min (with comparer)

        /// <summary>
        /// Renvoie la valeur maximale de la séquence selon le comparateur spécifié
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la liste</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="comparer">Comparateur à utiliser</param>
        /// <returns>La valeur maximale de la séquence selon le comparateur spécifié</returns>
        public static TSource Max<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer)
        {
            source.CheckArgumentNull("source");
            return source.Extreme(comparer, 1);
        }

        /// <summary>
        /// Renvoie la valeur minimale de la séquence selon le comparateur spécifié
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la liste</typeparam>
        /// <param name="source">Séquence d'éléments</param>
        /// <param name="comparer">Comparateur à utiliser</param>
        /// <returns>La valeur minimale de la séquence selon le comparateur spécifié</returns>
        public static TSource Min<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer)
        {
            source.CheckArgumentNull("source");
            return source.Extreme(comparer, -1);
        }

        private static TSource Extreme<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer, int sign)
        {
            comparer = comparer ?? Comparer<TSource>.Default;
            TSource extreme = default(TSource);
            bool first = true;
            foreach (var item in source)
            {
                int compare = comparer.Compare(item, extreme);

                if (Math.Sign(compare) == sign || first)
                {
                    extreme = item;
                }
                first = false;
            }

            if (first)
                ThrowEmptySequence();

            return extreme;
        }

        #endregion

        #region AsIndexed, Unindex

        /// <summary>
        /// Associe un index à un élément d'une séquence
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        public class IndexedItem<T>
        {
            internal IndexedItem(int index, T value)
            {
                Index = index;
                Value = value;
            }

            /// <summary>
            /// Index de l'élément
            /// </summary>
            public int Index { get; private set; }

            /// <summary>
            /// Valeur de l'élément
            /// </summary>
            public T Value { get; private set; }
        }

        /// <summary>
        /// Associe à chaque élément de la séquence son index dans la séquence
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'éléments à indexer</param>
        /// <returns>Une séquence projetée où chaque élément est associé à son index</returns>
        public static IEnumerable<IndexedItem<TSource>> AsIndexed<TSource>(this IEnumerable<TSource> source)
        {
            return source.Select((v, i) => new IndexedItem<TSource>(i, v));
        }

        /// <summary>
        /// Dissocie chaque élément de la séquence de son index. Cette méthode effectue l'opération inverse de AsIndexed.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'éléments à dissocier de leur index</param>
        /// <returns>Une séquence d'éléments sans leur index</returns>
        public static IEnumerable<TSource> Unindex<TSource>(this IEnumerable<IndexedItem<TSource>> source)
        {
            return source.Select(x => x.Value);
        }

        #endregion

        #region TakeEvery, SkipEvery, GroupEvery

        /// <summary>
        /// Extrait un élément sur <c>frequency</c> à partir de la séquence d'entrée, à partir du premier élément.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="frequency">Fréquence des éléments à extraire</param>
        /// <returns>Une séquence contenant un élément sur <c>frequency</c> de la séquence d'entrée</returns>
        public static IEnumerable<TSource> TakeEvery<TSource>(this IEnumerable<TSource> source, int frequency)
        {
            return source.TakeEvery(frequency, 0);
        }

        /// <summary>
        /// Extrait un élément sur <c>frequency</c> à partir de la séquence d'entrée, à partir de la position spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="frequency">Fréquence des éléments à extraire</param>
        /// <param name="start">Position du premier élément à extraire</param>
        /// <returns>Une séquence contenant un élément sur <c>frequency</c> de la séquence d'entrée à partir de la position spécifiée</returns>
        public static IEnumerable<TSource> TakeEvery<TSource>(this IEnumerable<TSource> source, int frequency, int start)
        {
            if (frequency <= 0)
                throw new ArgumentException("frequency");
            if (start < 0)
                throw new ArgumentException("start");

            return source
                .Skip(start)
                .Where((item, index) => index % frequency == 0);
        }

        /// <summary>
        /// Renvoie les éléments de la séquence d'entrée, en sautant un élément sur <c>frequency</c> à partir de la position spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="frequency">Fréquence des éléments à sauter</param>
        /// <returns>Une séquence les éléments de la séquence d'entrée, en en sautant un sur <c>frequency</c> à partir de la position spécifiée</returns>
        public static IEnumerable<TSource> SkipEvery<TSource>(this IEnumerable<TSource> source, int frequency)
        {
            return source.SkipEvery(frequency, 0);
        }

        /// <summary>
        /// Renvoie les éléments de la séquence d'entrée, en sautant un élément sur <c>frequency</c> à partir du premier élément.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="frequency">Fréquence des éléments à sauter</param>
        /// <param name="start">Position du premier élément à sauter</param>
        /// <returns>Une séquence les éléments de la séquence d'entrée, en en sautant un sur <c>frequency</c> à partir du premier.</returns>
        public static IEnumerable<TSource> SkipEvery<TSource>(this IEnumerable<TSource> source, int frequency, int start)
        {
            if (frequency <= 0)
                throw new ArgumentException("frequency");

            return source
                .Where((item, index) => index < start ? true : (index - start) % frequency != 0);
        }

        /// <summary>
        /// Renvoie les éléments de la séquence d'entrée par groupes de <c>groupLength</c> éléments.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'éléments à grouper</param>
        /// <param name="groupLength">Longueur des groupes</param>
        /// <returns>Une séquence de groupes de <c>groupLength</c> éléments</returns>
        /// <remarks>Si le nombre total d'éléments dans la séquence n'est pas un multiple de <c>groupLength</c>, le dernier groupe renvoyé contiendra moins de <c>groupLength</c> éléments.</remarks>
        public static IEnumerable<IEnumerable<TSource>> GroupEvery<TSource>(this IEnumerable<TSource> source, int groupLength)
        {
            if (groupLength <= 0)
                throw new ArgumentOutOfRangeException("groupLength");

            return source
                    .AsIndexed()
                    .GroupBy(x => x.Index / groupLength)
                    .Select(g => g.Unindex());
        }

        #endregion

        #region SkipFirst, SkipLast, SkipAt

        /// <summary>
        /// Renvoie les éléments de la séquence d'entrée en sautant le premier.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <returns>La séquence d'entrée sans le premier élément</returns>
        public static IEnumerable<TSource> SkipFirst<TSource>(this IEnumerable<TSource> source)
        {
            source.CheckArgumentNull("source");
            return source.Skip(1);
        }

        /// <summary>
        /// Renvoie les éléments de la séquence d'entrée en sautant le premier élément qui vérifie le prédicat spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="predicate">Prédicat à évaluer pour déterminer s'il faut sauter l'élément</param>
        /// <returns>La séquence d'entrée sans le premier élément qui vérifie le prédicat</returns>
        public static IEnumerable<TSource> SkipFirst<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            source.CheckArgumentNull("source");
            predicate.CheckArgumentNull("predicate");
            return source.SkipFirstIterator(predicate);
        }

        private static IEnumerable<TSource> SkipFirstIterator<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            bool skipped = false;
            foreach (var item in source)
            {
                if (!skipped && predicate(item))
                {
                    skipped = true;
                    continue;
                }

                yield return item;
            }
        }

        /// <summary>
        /// Renvoie les éléments de la séquence d'entrée en sautant le dernier élément qui vérifie le prédicat spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="predicate">Prédicat à évaluer pour déterminer s'il faut sauter l'élément</param>
        /// <returns>La séquence d'entrée sans le dernier élément qui vérifie le prédicat</returns>
        public static IEnumerable<TSource> SkipLast<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            source.CheckArgumentNull("source");
            predicate.CheckArgumentNull("predicate");
            return source.SkipLastIterator(predicate);
        }

        private static IEnumerable<TSource> SkipLastIterator<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            var queue = new Queue<TSource>();
            var last = default(TSource);
            bool any = false;

            foreach (var item in source)
            {
                if (predicate(item))
                {
                    if (any)
                        yield return last;

                    while (queue.Count > 0)
                        yield return queue.Dequeue();

                    last = item;
                    any = true;
                }
                else
                {
                    if (any)
                        queue.Enqueue(item);
                    else
                        yield return item;
                }
            }

            while (queue.Count > 0)
                yield return queue.Dequeue();
        }

        /// <summary>
        /// Renvoie les éléments de la séquence d'entrée en sautant l'élément qui se trouve à la position spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="index">Position de l'élément à sauter</param>
        /// <returns>La séquence d'entrée sans l'élément qui se trouvait à la position spécifiée</returns>
        public static IEnumerable<TSource> SkipAt<TSource>(this IEnumerable<TSource> source, int index)
        {
            return source.Where((it, i) => i != index);
        }

        #endregion

        #region TakeLast

        /// <summary>
        /// Renvoie le nombre spécifié d'éléments de la fin d'une séquence
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="count">Nombre maximum d'éléments à renvoyer</param>
        /// <returns>Les <c>count</c> derniers éléments de la séquence</returns>
        public static IEnumerable<TSource> TakeLast<TSource>(this IEnumerable<TSource> source, int count)
        {
            source.CheckArgumentNull("source");
            if (count < 0)
                throw new ArgumentOutOfRangeException(
                    "count",
                    string.Format(ExceptionMessages.NumberMustBePositiveOrZero, "count"));
            return source.TakeLastIterator(count);
        }

        private static IEnumerable<TSource> TakeLastIterator<TSource>(this IEnumerable<TSource> source, int count)
        {
            if (count <= 0)
                yield break;

            IList<TSource> list = source as IList<TSource>;
            if (list != null)
            {
                count = Math.Min(count, list.Count);
                for (int i = count; i > 0; i--)
                {
                    yield return list[list.Count - i];
                }
            }
            else
            {
                var queue = new Queue<TSource>();
                foreach (var item in source)
                {
                    if (queue.Count == count)
                        queue.Dequeue();
                    queue.Enqueue(item);
                }

                foreach (var item in queue)
                    yield return item;
            }
        }

        #endregion

        #region Replace, ReplaceAt

        /// <summary>
        /// Remplace toutes les occurrences de l'élément spécifié dans une séquence par un autre élément spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="oldItem">Elément à remplacer</param>
        /// <param name="newItem">Elément qui remplace l'ancien élément</param>
        /// <returns>Séquence dans laquelle l'ancien élément a été remplacé par le nouveau</returns>
        public static IEnumerable<TSource> Replace<TSource>(this IEnumerable<TSource> source, TSource oldItem, TSource newItem)
        {
            return source.Replace(oldItem, newItem, null);
        }

        /// <summary>
        /// Remplace toutes les occurrences de l'élément spécifié dans une séquence par un autre élément spécifié,
        /// en utilisant le comparateur d'égalité spécifié
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="oldItem">Elément à remplacer</param>
        /// <param name="newItem">Elément qui remplace l'ancien élément</param>
        /// <param name="comparer">Comprateur d'égalité à utiliser</param>
        /// <returns>Séquence dans laquelle l'ancien élément a été remplacé par le nouveau</returns>
        public static IEnumerable<TSource> Replace<TSource>(this IEnumerable<TSource> source, TSource oldItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            comparer = comparer ?? EqualityComparer<TSource>.Default;
            return source.Select((it, i) => comparer.Equals(it, oldItem) ? newItem : it);
        }

        /// <summary>
        /// Remplace l'élément à la position spécifiée d'une séquence par un élément spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="index">Position à laquelle effectuer le remplacement</param>
        /// <param name="item">Elément qui remplace l'élément à la position spécifiée</param>
        /// <returns>Séquence dans laquelle un élément a été remplacé</returns>
        public static IEnumerable<TSource> ReplaceAt<TSource>(this IEnumerable<TSource> source, int index, TSource item)
        {
            return source.Select((it, i) => i == index ? item : it);
        }

        #endregion

        #region InsertAt, InsertBefore(First), InsertAfter(First)

        /// <summary>
        /// Insère un élément à la position spécifiée d'une séquence.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="index">Position à laquelle insérer l'élément</param>
        /// <param name="item">Elément à insérer</param>
        /// <returns>Séquence dans laquelle un élément a été inséré</returns>
        public static IEnumerable<TSource> InsertAt<TSource>(this IEnumerable<TSource> source, int index, TSource item)
        {
            source.CheckArgumentNull("source");
            index.CheckArgumentOutOfRange("index", 0, int.MaxValue);
            return source.InsertAtIterator(index, item);
        }

        private static IEnumerable<TSource> InsertAtIterator<TSource>(this IEnumerable<TSource> source, int index, TSource item)
        {
            int i = 0;
            foreach (var it in source)
            {
                if (i++ == index)
                    yield return item;

                yield return it;
            }
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence juste avant la première occurrence de l'élément de référence spécifié
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence avant lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        ///<returns>Séquence avec le nouvel élément placé avant la première occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertBeforeFirst<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem)
        {
            return source.InsertBeforeFirst(refItem, newItem, null);
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence juste avant la première occurrence de l'élément de référence spécifié,
        /// en utilisant le comparateur d'égalité spécifié.
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence avant lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        /// <param name="comparer">Comparateur d'égalité à utiliser</param>
        ///<returns>Séquence avec le nouvel élément placé avant la première occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertBeforeFirst<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            source.CheckArgumentNull("source");
            return source.InsertBeforeFirstIterator(refItem, newItem, comparer);
        }

        private static IEnumerable<TSource> InsertBeforeFirstIterator<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            comparer = comparer ?? EqualityComparer<TSource>.Default;
            bool inserted = false;
            foreach (var item in source)
            {
                if (!inserted && comparer.Equals(item, refItem))
                {
                    yield return newItem;
                    inserted = true;
                }
                yield return item;
            }
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence juste après la première occurrence de l'élément de référence spécifié
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence après lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        ///<returns>Séquence avec le nouvel élément placé après la première occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertAfterFirst<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem)
        {
            return source.InsertAfterFirst(refItem, newItem, null);
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence juste après la première occurrence de l'élément de référence spécifié,
        /// en utilisant le comparateur d'égalité spécifié.
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence après lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        ///<param name="comparer">Comparateur d'égalité à utiliser</param>
        ///<returns>Séquence avec le nouvel élément placé après la première occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertAfterFirst<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            source.CheckArgumentNull("source");
            return source.InsertAfterFirstIterator(refItem, newItem, comparer);
        }

        private static IEnumerable<TSource> InsertAfterFirstIterator<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            comparer = comparer ?? EqualityComparer<TSource>.Default;
            bool inserted = false;
            foreach (var item in source)
            {
                yield return item;
                if (!inserted && comparer.Equals(item, refItem))
                {
                    yield return newItem;
                    inserted = true;
                }
            }
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence avant chaque occurrence de l'élément de référence spécifié
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence avant lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        ///<returns>Séquence avec le nouvel élément placé avant chaque occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertBefore<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem)
        {
            return source.InsertBefore(refItem, newItem, null);
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence avant chaque occurrence de l'élément de référence spécifié,
        /// en utilisant le comparateur d'égalité spécifié.
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence avant lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        /// <param name="comparer">Comparateur d'égalité à utiliser</param>
        ///<returns>Séquence avec le nouvel élément placé avant chaque occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertBefore<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            source.CheckArgumentNull("source");
            return source.InsertBeforeIterator(refItem, newItem, comparer);
        }

        private static IEnumerable<TSource> InsertBeforeIterator<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            comparer = comparer ?? EqualityComparer<TSource>.Default;
            foreach (var item in source)
            {
                if (comparer.Equals(item, refItem))
                    yield return newItem;
                yield return item;
            }
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence après chaque occurrence de l'élément de référence spécifié
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence après lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        ///<returns>Séquence avec le nouvel élément placé après chaque occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertAfter<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem)
        {
            return source.InsertAfter(refItem, newItem, null);
        }

        ///<summary>
        /// Insère un nouvel élément dans une séquence après chaque occurrence de l'élément de référence spécifié,
        /// en utilisant le comparateur d'égalité spécifié.
        ///</summary>
        ///<typeparam name="TSource">Type des éléments de la séquence</typeparam>
        ///<param name="source">Séquence d'entrée</param>
        ///<param name="refItem">Elément de référence après lequel on insère le nouvel élément</param>
        ///<param name="newItem">Nouvel élément à insérer</param>
        ///<param name="comparer">Comparateur d'égalité à utiliser</param>
        ///<returns>Séquence avec le nouvel élément placé après chaque occurrence de l'élément de référence</returns>
        public static IEnumerable<TSource> InsertAfter<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            source.CheckArgumentNull("source");
            return source.InsertAfterIterator(refItem, newItem, comparer);
        }

        private static IEnumerable<TSource> InsertAfterIterator<TSource>(this IEnumerable<TSource> source, TSource refItem, TSource newItem, IEqualityComparer<TSource> comparer)
        {
            comparer = comparer ?? EqualityComparer<TSource>.Default;
            foreach (var item in source)
            {
                yield return item;
                if (comparer.Equals(item, refItem))
                    yield return newItem;
            }
        }

        #endregion

        #region None

        /// <summary>
        /// Indique si une séquence ne contient aucun élément
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence à vérifier</param>
        /// <returns>true si <c>source</c> ne contient aucun élément ; sinon, false</returns>
        public static bool None<TSource>(this IEnumerable<TSource> source)
        {
            return !source.Any();
        }

        /// <summary>
        /// Indique s'il n'existe dans la séquence aucun élément qui satisfait le prédicat
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence à vérifier</param>
        /// <param name="predicate">Prédicat à évaluer pour chaque élément de la séquence</param>
        /// <returns>true si la séquence ne contient aucun élément qui satisfait le prédicat ; sinon, false</returns>
        public static bool None<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
        {
            return !source.Any(predicate);
        }

        #endregion

        #region ContainsAny

        /// <summary>
        /// Indique si une séquence contient au moins un des éléments spécifiés, en utilisant le comparateur par défaut
        /// </summary>
        /// <typeparam name="TSource">Type des élements de la séquence</typeparam>
        /// <param name="source">Séquence dans laquelle rechercher des éléments</param>
        /// <param name="items">Eléments à rechercher</param>
        /// <returns>true si <c>source</c> contient au moins un des éléments de <c>items</c>, false sinon</returns>
        public static bool ContainsAny<TSource>(this IEnumerable<TSource> source, IEnumerable<TSource> items)
        {
            return ContainsAny(source, items, EqualityComparer<TSource>.Default);
        }

        /// <summary>
        /// Indique si une séquence contient au moins un des éléments spécifiés, en utilisant le comparateur spécifié
        /// </summary>
        /// <typeparam name="TSource">Type des élements de la séquence</typeparam>
        /// <param name="source">Séquence dans laquelle rechercher des éléments</param>
        /// <param name="items">Eléments à rechercher</param>
        /// <param name="comparer">Comparateur à utiliser</param>
        /// <returns>true si <c>source</c> contient au moins un des éléments de <c>items</c>, false sinon</returns>
        public static bool ContainsAny<TSource>(this IEnumerable<TSource> source, IEnumerable<TSource> items, IEqualityComparer<TSource> comparer)
        {
            return source.Intersect(items, comparer).Any();
        }

        #endregion

        #region IndexOf

        /// <summary>
        /// Renvoie l'index de la première occurence de l'élément spécifié dans la séquence
        /// </summary>
        /// <typeparam name="T">Le type des éléments de la séquence</typeparam>
        /// <param name="source">La séquence dans laquelle chercher l'élément</param>
        /// <param name="item">L'élément à rechercher</param>
        /// <returns>L'index de la première occurence de l'élément dans la séquence, ou -1 si l'élément ne s'y trouve pas.</returns>
        public static int IndexOf<T>(this IEnumerable<T> source, T item)
        {
            return source.IndexOf(item, null);
        }

        /// <summary>
        /// Renvoie l'index de la première occurence de l'élément spécifié dans la séquence, en utilisant le comparateur spécifié.
        /// </summary>
        /// <typeparam name="T">Le type des éléments de la séquence</typeparam>
        /// <param name="source">La séquence dans laquelle chercher l'élément</param>
        /// <param name="item">L'élément à rechercher</param>
        /// <param name="comparer">Comparateur à utiliser pour tester l'égalité des éléments</param>
        /// <returns>L'index de la première occurence de l'élément dans la séquence, ou -1 si l'élément ne s'y trouve pas.</returns>
        public static int IndexOf<T>(this IEnumerable<T> source, T item, IEqualityComparer<T> comparer)
        {
            source.CheckArgumentNull("source");
            comparer = comparer ?? EqualityComparer<T>.Default;
            return source.AsIndexed()
                        .Where(x => comparer.Equals(x.Value, item))
                        .Select(x => x.Index)
                        .FirstOrDefault(-1);
        }

        /// <summary>
        /// Renvoie l'index du premier élément pour lequel le prédicat spécifié est vérifié
        /// </summary>
        /// <typeparam name="T">Le type des éléments de la séquence</typeparam>
        /// <param name="source">La séquence dans laquelle chercher l'élément</param>
        /// <param name="predicate">Le prédicat à évaluer</param>
        /// <returns>L'index du premier élément pour lequel le prédicat est vérifié, ou -1 si aucun élément ne vérifie le prédicat.</returns>
        public static int IndexOf<T>(this IEnumerable<T> source, Func<T, bool> predicate)
        {
            return source.AsIndexed()
                        .Where(x => predicate(x.Value))
                        .Select(x => x.Index)
                        .FirstOrDefault(-1);
        }

        /// <summary>
        /// Renvoie l'index de la dernière occurence de l'élément spécifié dans la séquence
        /// </summary>
        /// <typeparam name="T">Le type des éléments de la séquence</typeparam>
        /// <param name="source">La séquence dans laquelle chercher l'élément</param>
        /// <param name="item">L'élément à rechercher</param>
        /// <returns>L'index de la dernière occurence de l'élément dans la séquence, ou -1 si l'élément ne s'y trouve pas.</returns>
        public static int LastIndexOf<T>(this IEnumerable<T> source, T item)
        {
            return source.LastIndexOf(item, null);
        }

        /// <summary>
        /// Renvoie l'index de la dernière occurence de l'élément spécifié dans la séquence, en utilisant le comparateur spécifié.
        /// </summary>
        /// <typeparam name="T">Le type des éléments de la séquence</typeparam>
        /// <param name="source">La séquence dans laquelle chercher l'élément</param>
        /// <param name="item">L'élément à rechercher</param>
        /// <param name="comparer">Comparateur à utiliser pour tester l'égalité des éléments</param>
        /// <returns>L'index de la dernière occurence de l'élément dans la séquence, ou -1 si l'élément ne s'y trouve pas.</returns>
        public static int LastIndexOf<T>(this IEnumerable<T> source, T item, IEqualityComparer<T> comparer)
        {
            source.CheckArgumentNull("source");
            comparer = comparer ?? EqualityComparer<T>.Default;
            return source.AsIndexed()
                        .Where(x => comparer.Equals(x.Value, item))
                        .Select(x => x.Index)
                        .LastOrDefault(-1);
        }

        /// <summary>
        /// Renvoie l'index du dernier élément pour lequel le prédicat spécifié est vérifié
        /// </summary>
        /// <typeparam name="T">Le type des éléments de la séquence</typeparam>
        /// <param name="source">La séquence dans laquelle chercher l'élément</param>
        /// <param name="predicate">Le prédicat à évaluer</param>
        /// <returns>L'index du dernier élément pour lequel le prédicat est vérifié, ou -1 si aucun élément ne vérifie le prédicat.</returns>
        public static int LastIndexOf<T>(this IEnumerable<T> source, Func<T, bool> predicate)
        {
            return source.AsIndexed()
                        .Where(x => predicate(x.Value))
                        .Select(x => x.Index)
                        .LastOrDefault(-1);
        }

        #endregion

        #region CopyTo

        /// <summary>
        /// Copie tous les éléments de la séquence vers le tableau spécifié
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence à partir de laquelle copier les éléments</param>
        /// <param name="array">Tableau vers lequel copier les éléments</param>
        /// <param name="arrayIndex">Position dans le tableau à partir de laquelle les éléments sont copiés</param>
        public static void CopyTo<T>(this IEnumerable<T> source, T[] array, int arrayIndex)
        {
            int lowerBound = array.GetLowerBound(0);
            int upperBound = array.GetUpperBound(0);
            if (arrayIndex < lowerBound || arrayIndex > upperBound)
                throw new ArgumentOutOfRangeException("arrayIndex");

            int i = 0;
            foreach (var item in source)
            {
                if (arrayIndex + i > upperBound)
                    throw new ArgumentException(ExceptionMessages.ArrayCapacityInsufficient);
                array[arrayIndex + i] = item;
                i++;
            }
        }

        #endregion

        #region Apply

        /// <summary>
        /// Applique l'action spécifiée "au passage" sur chaque élément de la séquence
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'origine</param>
        /// <param name="action">Action à effectuer sur chaque élément de la séquence</param>
        /// <returns>La séquence d'origine</returns>
        /// <remarks>Cette méthode s'utilise uniquement avec des types référence. Pour les types valeur,
        /// le paramètre de l'action doit être passé par référence.</remarks>
        public static IEnumerable<T> Apply<T>(this IEnumerable<T> source, Action<T> action)
            where T : class
        {
            action.CheckArgumentNull("action");
            return source.ApplyIterator(action);
        }

        private static IEnumerable<T> ApplyIterator<T>(this IEnumerable<T> source, Action<T> action)
            where T : class
        {
            foreach (var item in source)
            {
                action(item);
                yield return item;
            }
        }

        /// <summary>
        /// Représente une action avec un paramètre passé par référence
        /// </summary>
        /// <typeparam name="T">Type du paramètre</typeparam>
        /// <param name="param">Paramètre de l'action</param>
        public delegate void ByRefAction<T>(ref T param);

        /// <summary>
        /// Applique l'action spécifiée "au passage" sur chaque élément de la séquence
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'origine</param>
        /// <param name="action">Action à effectuer sur chaque élément de la séquence</param>
        /// <returns>La séquence d'origine</returns>
        /// <remarks>Cette méthode s'utilise uniquement avec des types valeur. Pour les types référence,
        /// le paramètre de l'action doit être passé par valeur.</remarks>
        public static IEnumerable<T> Apply<T>(this IEnumerable<T> source, ByRefAction<T> action)
            where T : struct
        {
            action.CheckArgumentNull("action");
            return source.ApplyIterator(action);
        }

        private static IEnumerable<T> ApplyIterator<T>(this IEnumerable<T> source, ByRefAction<T> action)
            where T : struct
        {
            foreach (var item in source)
            {
                T it = item;
                action(ref it);
                yield return it;
            }
        }

        #endregion

        #region IndexOfSequence

        /// <summary>
        /// Renvoie la position de début de la première occurence de la sous-séquence spécifiée dans la séquence source,
        /// en utilisant le comparateur par défaut.
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence source dans laquelle on recherche une sous-séquence</param>
        /// <param name="sequence">Sous-séquence à rechercher</param>
        /// <returns>La position de la première occurence de <c>sequence</c> dans <c>source</c>, ou -1 si la sous-séquence n'est pas trouvée.</returns>
        public static int IndexOfSequence<T>(this IEnumerable<T> source, IEnumerable<T> sequence)
        {
            return source.IndexOfSequence(sequence, null);
        }

        /// <summary>
        /// Renvoie la position de début de la première occurence de la sous-séquence spécifiée dans la séquence source,
        /// en utilisant le comparateur spécifié.
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence source dans laquelle on recherche une sous-séquence</param>
        /// <param name="sequence">Sous-séquence à rechercher</param>
        /// <param name="comparer">Comparateur à utiliser</param>
        /// <returns>La position de la première occurence de <c>sequence</c> dans <c>source</c>, ou -1 si la sous-séquence n'est pas trouvée.</returns>
        public static int IndexOfSequence<T>(this IEnumerable<T> source, IEnumerable<T> sequence, IEqualityComparer<T> comparer)
        {
            source.CheckArgumentNull("source");
            sequence.CheckArgumentNull("sequence");

            comparer = comparer ?? EqualityComparer<T>.Default;

            var seq = sequence.ToArray();

            int p = 0; // current position in source sequence
            int i = 0; // current position in searched sequence
            var prospects = new List<int>(); // list of prospective matches
            foreach (var item in source)
            {
                // ReSharper disable AccessToModifiedClosure
                // Remove bad prospective matches
                prospects.RemoveAll(k => !comparer.Equals(item, seq[p - k]));
                // ReSharper restore AccessToModifiedClosure

                // Is it the start of a prospective match ?
                if (comparer.Equals(item, seq[0]))
                {
                    prospects.Add(p);
                }

                // Does current character continues partial match ?
                if (comparer.Equals(item, seq[i]))
                {
                    i++;
                    // Do we have a complete match ?
                    if (i == seq.Length)
                    {
                        // Bingo !
                        return p - seq.Length + 1;
                    }
                }
                else // Mismatch
                {
                    // Do we have prospective matches to fall back to ?
                    if (prospects.Count > 0)
                    {
                        // Yes, use the first one
                        int k = prospects[0];
                        i = p - k + 1;
                    }
                    else
                    {
                        // No, start from beginning of searched sequence
                        i = 0;
                    }
                }
                p++;
            }
            // No match
            return -1;
        }

        #endregion

        #region Split

        /// <summary>
        /// Divise une séquence d'éléments en plusieurs parties à chaque fois qu'un séparateur
        /// est rencontré.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'éléments à diviser</param>
        /// <param name="isSeparator">Prédicat qui détermine si un élément de la liste est un séparateur</param>
        /// <returns>Une séquence de parties de la séquence d'origine</returns>
        public static IEnumerable<IEnumerable<TSource>> Split<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> isSeparator)
        {
            source.CheckArgumentNull("source");
            isSeparator.CheckArgumentNull("isSeparator");
            return source.SplitIterator(isSeparator);
        }

        private static IEnumerable<IEnumerable<T>> SplitIterator<T>(this IEnumerable<T> source, Func<T, bool> isSeparator)
        {
            List<T> list = new List<T>();
            foreach (var item in source)
            {
                if (isSeparator(item))
                {
                    if (list.Count > 0)
                    {
                        yield return list.AsReadOnly();
                        list = new List<T>();
                    }
                }
                else
                {
                    list.Add(item);
                }
            }

            if (list.Count > 0)
                yield return list.AsReadOnly();
        }

        #endregion

        #region DistinctBy

        /// <summary>
        /// Retourne des éléments distincts d'une séquence, en les comparant selon la clé spécifiée
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Séquence de laquelle supprimer les éléments en double</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <returns>Une séquence contenant des éléments distincts de la séquence d'origine</returns>
        public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return source.DistinctBy(keySelector, null);
        }

        /// <summary>
        /// Retourne des éléments distincts d'une séquence, en les comparant selon la clé spécifiée,
        /// et en comparant les clés avec le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Séquence de laquelle supprimer les éléments en double</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <param name="keyComparer">Comparateur à utiliser pour comparer les clés. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Une séquence contenant des éléments distincts de la séquence d'origine</returns>
        public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
        {
            source.CheckArgumentNull("source");
            keySelector.CheckArgumentNull("keySelector");
            return source.Distinct(new KeyEqualityComparer<TSource, TKey>(keySelector, keyComparer));
        }

        #endregion

        #region ExceptBy

        /// <summary>
        /// Retourne des éléments de la première séquence qui n'appartiennent pas à la deuxième, en les comparant selon la clé spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <returns>Une séquence contenant les éléments de la première séquence qui n'appartiennent pas à la deuxième</returns>
        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector)
        {
            return source.ExceptBy(other, keySelector, null);
        }

        /// <summary>
        /// Retourne des éléments de la première séquence qui n'appartiennent pas à la deuxième, en les comparant selon la clé spécifiée,
        /// et en comparant les clés avec le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <param name="keyComparer">Comparateur à utiliser pour comparer les clés. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Une séquence contenant les éléments de la première séquence qui n'appartiennent pas à la deuxième</returns>
        public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
        {
            source.CheckArgumentNull("source");
            other.CheckArgumentNull("other");
            keySelector.CheckArgumentNull("keySelector");
            return source.Except(other, new KeyEqualityComparer<TSource, TKey>(keySelector, keyComparer));
        }

        #endregion

        #region UnionBy

        /// <summary>
        /// Produit l'union de deux séquences en comparant les éléments selon la clé spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <returns>Séquence constituée des éléments des deux séquences d'entrée, sans les doublons</returns>
        public static IEnumerable<TSource> UnionBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector)
        {
            return source.UnionBy(other, keySelector, null);
        }

        /// <summary>
        /// Produit l'union de deux séquences en comparant les éléments selon la clé spécifiée, et en comparant les clés à l'aide du comparateur d'égalité spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <param name="keyComparer">Comparateur à utiliser pour comparer les clés. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Séquence constituée des éléments des deux séquences d'entrée, sans les doublons</returns>
        public static IEnumerable<TSource> UnionBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
        {
            source.CheckArgumentNull("source");
            other.CheckArgumentNull("other");
            keySelector.CheckArgumentNull("keySelector");
            return source.Union(other, new KeyEqualityComparer<TSource, TKey>(keySelector, keyComparer));
        }

        #endregion

        #region IntersectBy

        /// <summary>
        /// Produit l'intersection de deux séquences en comparant les éléments selon la clé spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <returns>Séquence constituée des éléments des deux séquences présents dans les deux séquences d'entrée, sans les doublons</returns>
        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector)
        {
            return source.IntersectBy(other, keySelector, null);
        }

        /// <summary>
        /// Produit l'intersection de deux séquences en comparant les éléments selon la clé spécifiée, et en comparant les clés à l'aide du comparateur d'égalité spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <param name="keyComparer">Comparateur à utiliser pour comparer les clés. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Séquence constituée des éléments des deux séquences présents dans les deux séquences d'entrée, sans les doublons</returns>
        public static IEnumerable<TSource> IntersectBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
        {
            source.CheckArgumentNull("source");
            other.CheckArgumentNull("other");
            keySelector.CheckArgumentNull("keySelector");
            return source.Intersect(other, new KeyEqualityComparer<TSource, TKey>(keySelector, keyComparer));
        }

        #endregion

        #region SequenceEqualBy

        /// <summary>
        /// Détermine si deux séquences sont égales en comparant les éléments selon la clé spécifiée.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <returns>true si les deux séquences source sont de même longueur et si leurs éléments ont la même valeur pour la clé spécifiée ; sinon, false.</returns>
        public static bool SequenceEqualBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector)
        {
            return source.SequenceEqualBy(other, keySelector, null);
        }

        /// <summary>
        /// Détermine si deux séquences sont égales en comparant les éléments selon la clé spécifiée, et en comparant les clés à l'aide du comparateur d'égalité spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <param name="keyComparer">Comparateur à utiliser pour comparer les clés. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>true si les deux séquences source sont de même longueur et si leurs éléments ont la même valeur pour la clé spécifiée ; sinon, false.</returns>
        public static bool SequenceEqualBy<TSource, TKey>(this IEnumerable<TSource> source, IEnumerable<TSource> other, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
        {
            source.CheckArgumentNull("source");
            other.CheckArgumentNull("other");
            keySelector.CheckArgumentNull("keySelector");
            return source.SequenceEqual(other, new KeyEqualityComparer<TSource, TKey>(keySelector, keyComparer));
        }

        #endregion

        #region GetElementType

        /// <summary>
        /// Renvoie le type des éléments d'une séquence
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence dont on veut obtenir le type des éléments</param>
        /// <returns>Le type des éléments de la séquence</returns>
        // ReSharper disable UnusedParameter.Global
        public static Type GetElementType<T>(this IEnumerable<T> source)
        // ReSharper restore UnusedParameter.Global
        {
            return typeof(T);
        }

        #endregion

        #region ElementDefaultValue

        /// <summary>
        /// Renvoie la valeur par défaut du type des éléments d'une séquence. Utile pour déclarer une variable d'un type anonyme.
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence</param>
        /// <returns>La valeur par défaut du type des éléments de la séquence</returns>
        // ReSharper disable UnusedParameter.Global
        public static T ElementDefaultValue<T>(IEnumerable<T> source)
        // ReSharper restore UnusedParameter.Global
        {
            return default(T);
        }

        #endregion

        #region CommonPrefix

        /// <summary>
        /// Renvoie le préfixe commun de deux séquences, en utilisant le comparateur par défaut
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <returns>Une séquence contenant les premiers éléments de <c>source</c> tant qu'ils sont égaux à ceux de <c>other</c></returns>
        public static IEnumerable<T> CommonPrefix<T>(this IEnumerable<T> source, IEnumerable<T> other)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (other == null)
                throw new ArgumentNullException("other");

            return source.CommonPrefixImpl(other, null);
        }

        /// <summary>
        /// Renvoie le préfixe commun de deux séquences, en utilisant le comparateur spécifié
        /// </summary>
        /// <typeparam name="T">Type des éléments de la séquence</typeparam>
        /// <param name="source">Première séquence</param>
        /// <param name="other">Deuxième séquence</param>
        /// <param name="comparer">Comparateur à utiliser pour déterminer l'égalité de deux éléments</param>
        /// <returns>Une séquence contenant les premiers éléments de <c>source</c> tant qu'ils sont égaux à ceux de <c>other</c></returns>
        public static IEnumerable<T> CommonPrefix<T>(this IEnumerable<T> source, IEnumerable<T> other, IEqualityComparer<T> comparer)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (other == null)
                throw new ArgumentNullException("other");

            return source.CommonPrefixImpl(other, comparer);
        }

        private static IEnumerable<T> CommonPrefixImpl<T>(this IEnumerable<T> source, IEnumerable<T> other, IEqualityComparer<T> comparer)
        {
            comparer = comparer ?? EqualityComparer<T>.Default;

            using (IEnumerator<T> en1 = source.GetEnumerator(),
                                  en2 = other.GetEnumerator())
            {
                while (en1.MoveNext() && en2.MoveNext())
                {
                    if (comparer.Equals(en1.Current, en2.Current))
                        yield return en1.Current;
                    else
                        yield break;
                }
            }
        }

        #endregion

        #region RankBy

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang selon la clé spécifiée
        /// en ordre croissant.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> RankBy<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.RankBy(keySelector, null, false, resultSelector);
        }

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang selon la clé spécifiée
        /// en ordre croissant, en utilisant le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les valeurs de la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> RankBy<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            IComparer<TKey> comparer,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.RankBy(keySelector, comparer, false, resultSelector);
        }

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang selon la clé spécifiée
        /// en ordre décroissant, en utilisant le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les valeurs de la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> RankByDescending<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            IComparer<TKey> comparer,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.RankBy(keySelector, comparer, true, resultSelector);
        }

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang selon la clé spécifiée
        /// en ordre décroissant.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> RankByDescending<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.RankBy(keySelector, null, true, resultSelector);
        }

        private static IEnumerable<TResult> RankBy<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            IComparer<TKey> comparer,
            bool descending,
            Func<TSource, int, TResult> resultSelector)
        {
            comparer = comparer ?? Comparer<TKey>.Default;

            var grouped = source.GroupBy(keySelector);
            var ordered =
                descending
                    ? grouped.OrderByDescending(g => g.Key, comparer)
                    : grouped.OrderBy(g => g.Key, comparer);

            int totalRank = 1;
            foreach (var group in ordered)
            {
                int rank = totalRank;
                foreach (var item in group)
                {
                    yield return resultSelector(item, rank);
                    totalRank++;
                }
            }
        }

        #endregion

        #region DenseRankBy

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang, sans vide dans le classement,
        /// selon la clé spécifiée en ordre croissant.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> DenseRankBy<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.DenseRankBy(keySelector, null, false, resultSelector);
        }

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang, sans vide dans le classement,
        ///  selon la clé spécifiée en ordre croissant, en utilisant le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les valeurs de la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> DenseRankBy<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            IComparer<TKey> comparer,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.DenseRankBy(keySelector, comparer, false, resultSelector);
        }

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang, sans vide dans le classement,
        /// selon la clé spécifiée en ordre décroissant, en utilisant le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les valeurs de la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> DenseRankByDescending<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            IComparer<TKey> comparer,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.DenseRankBy(keySelector, comparer, true, resultSelector);
        }

        /// <summary>
        /// Associe à chaque élément d'une séquence son rang, sans vide dans le classement,
        /// selon la clé spécifiée en ordre décroissant.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence d'entrée</typeparam>
        /// <typeparam name="TKey">Type de la clé de tri</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence de sortie</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui sélectionne la clé de tri</param>
        /// <param name="resultSelector">Fonction qui associe le rang à chaque élément</param>
        /// <returns>La séquence des éléments d'entrée associés à leur rang</returns>
        public static IEnumerable<TResult> DenseRankByDescending<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            Func<TSource, int, TResult> resultSelector)
        {
            return source.DenseRankBy(keySelector, null, true, resultSelector);
        }

        private static IEnumerable<TResult> DenseRankBy<TSource, TKey, TResult>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            IComparer<TKey> comparer,
            bool descending,
            Func<TSource, int, TResult> resultSelector)
        {
            comparer = comparer ?? Comparer<TKey>.Default;

            var grouped = source.GroupBy(keySelector);
            var ordered =
                descending
                    ? grouped.OrderByDescending(g => g.Key, comparer)
                    : grouped.OrderBy(g => g.Key, comparer);

            int rank = 1;
            foreach (var group in ordered)
            {
                foreach (var item in group)
                {
                    yield return resultSelector(item, rank);
                }
                rank++;
            }
        }

        #endregion

        #region Outer joins

        #region Left

        /// <summary>
        /// Effectue la jointure externe gauche entre 2 séquences. Chaque élément de la première séquence est associé
        /// à chaque élément correspondant de la seconde, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la seconde séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> LeftOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector)
        {
            return outer.LeftOuterJoin(inner, outerKeySelector, innerKeySelector, resultSelector, default(TInner), null);
        }

        /// <summary>
        /// Effectue la jointure externe gauche entre 2 séquences. Chaque élément de la première séquence est associé
        /// à chaque élément correspondant de la seconde, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la seconde séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="defaultInner">Valeur par défaut quand aucun élément correspondant n'existe dans la seconde séquence</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> LeftOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector,
            TInner defaultInner)
        {
            return outer.LeftOuterJoin(inner, outerKeySelector, innerKeySelector, resultSelector, defaultInner, null);
        }

        /// <summary>
        /// Effectue la jointure externe gauche entre 2 séquences. Chaque élément de la première séquence est associé
        /// à chaque élément correspondant de la seconde, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la seconde séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les clés de jointure</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> LeftOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector,
            IEqualityComparer<TKey> comparer)
        {
            return outer.LeftOuterJoin(inner, outerKeySelector, innerKeySelector, resultSelector, default(TInner), comparer);
        }

        /// <summary>
        /// Effectue la jointure externe gauche entre 2 séquences. Chaque élément de la première séquence est associé
        /// à chaque élément correspondant de la seconde, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la seconde séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="defaultInner">Valeur par défaut quand aucun élément correspondant n'existe dans la seconde séquence</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les clés de jointure</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> LeftOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector,
            TInner defaultInner,
            IEqualityComparer<TKey> comparer)
        {
            outer.CheckArgumentNull("outer");
            inner.CheckArgumentNull("inner");
            outerKeySelector.CheckArgumentNull("outerKeySelector");
            innerKeySelector.CheckArgumentNull("innerKeySelector");
            resultSelector.CheckArgumentNull("resultSelector");

            return outer.GroupJoin(
                            inner,
                            outerKeySelector,
                            innerKeySelector,
                            (left, tmp) => new { left, tmp },
                            comparer)
                        .SelectMany(
                            g => g.tmp.DefaultIfEmpty(defaultInner),
                            (g, right) => resultSelector(g.left, right));
        }

        #endregion

        #region Right

        /// <summary>
        /// Effectue la jointure externe droite entre 2 séquences. Chaque élément de la seconde séquence est associé
        /// à chaque élément correspondant de la première, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la première séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> RightOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector)
        {
            return outer.RightOuterJoin(inner, outerKeySelector, innerKeySelector, resultSelector, default(TOuter), null);
        }

        /// <summary>
        /// Effectue la jointure externe droite entre 2 séquences. Chaque élément de la seconde séquence est associé
        /// à chaque élément correspondant de la première, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la première séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="defaultOuter">Valeur par défaut quand aucun élément correspondant n'existe dans la première séquence</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> RightOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector,
            TOuter defaultOuter)
        {
            return outer.RightOuterJoin(inner, outerKeySelector, innerKeySelector, resultSelector, defaultOuter, null);
        }

        /// <summary>
        /// Effectue la jointure externe droite entre 2 séquences. Chaque élément de la seconde séquence est associé
        /// à chaque élément correspondant de la première, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la première séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les clés de jointure</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> RightOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector,
            IEqualityComparer<TKey> comparer)
        {
            return outer.RightOuterJoin(inner, outerKeySelector, innerKeySelector, resultSelector, default(TOuter), comparer);
        }

        /// <summary>
        /// Effectue la jointure externe droite entre 2 séquences. Chaque élément de la seconde séquence est associé
        /// à chaque élément correspondant de la première, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans la première séquence.
        /// </summary>
        /// <typeparam name="TOuter">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TInner">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="outer">Première séquence à joindre</param>
        /// <param name="inner">Seconde séquence à joindre</param>
        /// <param name="outerKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="innerKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="defaultOuter">Valeur par défaut quand aucun élément correspondant n'existe dans la première séquence</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les clés de jointure</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> RightOuterJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner, TResult> resultSelector,
            TOuter defaultOuter,
            IEqualityComparer<TKey> comparer)
        {
            outer.CheckArgumentNull("outer");
            inner.CheckArgumentNull("inner");
            outerKeySelector.CheckArgumentNull("outerKeySelector");
            innerKeySelector.CheckArgumentNull("innerKeySelector");
            resultSelector.CheckArgumentNull("resultSelector");

            return inner.LeftOuterJoin(outer, innerKeySelector, outerKeySelector, (i, o) => resultSelector(o, i), defaultOuter, comparer);
        }

        #endregion

        #region Full

        /// <summary>
        /// Effectue la jointure externe totale entre 2 séquences. Chaque élément de la chaque séquence est associé
        /// à chaque élément correspondant de l'autre, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans l'autre séquence.
        /// </summary>
        /// <typeparam name="TLeft">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TRight">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="left">Première séquence à joindre</param>
        /// <param name="right">Seconde séquence à joindre</param>
        /// <param name="leftKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="rightKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> FullOuterJoin<TLeft, TRight, TKey, TResult>(
            this IEnumerable<TLeft> left,
            IEnumerable<TRight> right,
            Func<TLeft, TKey> leftKeySelector,
            Func<TRight, TKey> rightKeySelector,
            Func<TKey, TLeft, TRight, TResult> resultSelector)
        {
            return left.FullOuterJoin(right, leftKeySelector, rightKeySelector, resultSelector, default(TLeft), default(TRight), null);
        }

        /// <summary>
        /// Effectue la jointure externe totale entre 2 séquences. Chaque élément de la chaque séquence est associé
        /// à chaque élément correspondant de l'autre, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans l'autre séquence.
        /// </summary>
        /// <typeparam name="TLeft">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TRight">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="left">Première séquence à joindre</param>
        /// <param name="right">Seconde séquence à joindre</param>
        /// <param name="leftKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="rightKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="defaultLeft">Valeur par défaut quand aucun élément correspondant n'existe dans la première séquence</param>
        /// <param name="defaultRight">Valeur par défaut quand aucun élément correspondant n'existe dans la seconde séquence</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> FullOuterJoin<TLeft, TRight, TKey, TResult>(
            this IEnumerable<TLeft> left,
            IEnumerable<TRight> right,
            Func<TLeft, TKey> leftKeySelector,
            Func<TRight, TKey> rightKeySelector,
            Func<TKey, TLeft, TRight, TResult> resultSelector,
            TLeft defaultLeft,
            TRight defaultRight)
        {
            return left.FullOuterJoin(right, leftKeySelector, rightKeySelector, resultSelector, defaultLeft, defaultRight, null);
        }

        /// <summary>
        /// Effectue la jointure externe totale entre 2 séquences. Chaque élément de la chaque séquence est associé
        /// à chaque élément correspondant de l'autre, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans l'autre séquence.
        /// </summary>
        /// <typeparam name="TLeft">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TRight">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="left">Première séquence à joindre</param>
        /// <param name="right">Seconde séquence à joindre</param>
        /// <param name="leftKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="rightKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les clés de jointure</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> FullOuterJoin<TLeft, TRight, TKey, TResult>(
            this IEnumerable<TLeft> left,
            IEnumerable<TRight> right,
            Func<TLeft, TKey> leftKeySelector,
            Func<TRight, TKey> rightKeySelector,
            Func<TKey, TLeft, TRight, TResult> resultSelector,
            IEqualityComparer<TKey> comparer)
        {
            return left.FullOuterJoin(right, leftKeySelector, rightKeySelector, resultSelector, default(TLeft), default(TRight), comparer);
        }

        /// <summary>
        /// Effectue la jointure externe totale entre 2 séquences. Chaque élément de la chaque séquence est associé
        /// à chaque élément correspondant de l'autre, ou à une valeur par défaut s'il n'y a pas d'élément correspondant
        /// dans l'autre séquence.
        /// </summary>
        /// <typeparam name="TLeft">Type des éléments de la première séquence</typeparam>
        /// <typeparam name="TRight">Type des éléments de la seconde séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de jointure</typeparam>
        /// <typeparam name="TResult">Type des éléments de la séquence résultat</typeparam>
        /// <param name="left">Première séquence à joindre</param>
        /// <param name="right">Seconde séquence à joindre</param>
        /// <param name="leftKeySelector">Function de sélection de la clé de jointure pour la première séquence</param>
        /// <param name="rightKeySelector">Function de sélection de la clé de jointure pour la seconde séquence</param>
        /// <param name="resultSelector">Fonction de sélection du résultat à partir de deux éléments correspondants</param>
        /// <param name="defaultLeft">Valeur par défaut quand aucun élément correspondant n'existe dans la première séquence</param>
        /// <param name="defaultRight">Valeur par défaut quand aucun élément correspondant n'existe dans la seconde séquence</param>
        /// <param name="comparer">Comparateur utilisé pour comparer les clés de jointure</param>
        /// <returns>Le résultat de la jointure</returns>
        public static IEnumerable<TResult> FullOuterJoin<TLeft, TRight, TKey, TResult>(
            this IEnumerable<TLeft> left,
            IEnumerable<TRight> right,
            Func<TLeft, TKey> leftKeySelector,
            Func<TRight, TKey> rightKeySelector,
            Func<TKey, TLeft, TRight, TResult> resultSelector,
            TLeft defaultLeft,
            TRight defaultRight,
            IEqualityComparer<TKey> comparer)
        {
            left.CheckArgumentNull("left");
            right.CheckArgumentNull("right");
            leftKeySelector.CheckArgumentNull("leftKeySelector");
            rightKeySelector.CheckArgumentNull("rightKeySelector");
            resultSelector.CheckArgumentNull("resultSelector");

            var leftJoin = left.LeftOuterJoin(right, leftKeySelector, rightKeySelector, (l, r) => new { key = leftKeySelector(l), l, r }, defaultRight, comparer).Select(x => resultSelector(x.key, x.l, x.r));
            var rightJoin = left.RightOuterJoin(right, leftKeySelector, rightKeySelector, (l, r) => new { key = rightKeySelector(r), l, r }, defaultLeft, comparer).Select(x => resultSelector(x.key, x.l, x.r));
            return leftJoin.Union(rightJoin);
        }

        #endregion

        #endregion

        #region DistinctUntilChanged

        /// <summary>
        /// Renvoie une séquence qui contient seulement des valeurs contiguës distinctes.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <returns>Une séquence qui contient seulement des valeurs contiguës distinctes</returns>
        public static IEnumerable<TSource> DistinctUntilChanged<TSource>(this IEnumerable<TSource> source)
        {
            source.CheckArgumentNull("source");
            return source.DistinctUntilChanged(LinqHelper.Identity, null);
        }

        /// <summary>
        /// Renvoie une séquence qui contient seulement des valeurs contiguës distinctes selon le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="comparer">Comparateur à utiliser pour comparer les éléments. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Une séquence qui contient seulement des valeurs contiguës distinctes</returns>
        public static IEnumerable<TSource> DistinctUntilChanged<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
        {
            source.CheckArgumentNull("source");
            return source.DistinctUntilChanged(LinqHelper.Identity, comparer);
        }

        /// <summary>
        /// Renvoie une séquence qui contient seulement des valeurs contiguës distinctes selon le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de comparaison</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <returns>Une séquence qui contient seulement des valeurs contiguës distinctes</returns>
        public static IEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            source.CheckArgumentNull("source");
            keySelector.CheckArgumentNull("keySelector");
            return source.DistinctUntilChanged(keySelector, null);
        }

        /// <summary>
        /// Renvoie une séquence qui contient seulement des valeurs contiguës distinctes selon le comparateur spécifié.
        /// </summary>
        /// <typeparam name="TSource">Type des éléments de la séquence</typeparam>
        /// <typeparam name="TKey">Type de la clé de comparaison</typeparam>
        /// <param name="source">Séquence d'entrée</param>
        /// <param name="keySelector">Fonction qui renvoie la clé à utiliser pour comparer les éléments</param>
        /// <param name="comparer">Comparateur à utiliser pour comparer les clés. Si null, le comparateur par défaut sera utilisé</param>
        /// <returns>Une séquence qui contient seulement des valeurs contiguës distinctes</returns>
        public static IEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            source.CheckArgumentNull("source");
            comparer = comparer ?? EqualityComparer<TKey>.Default;
            using (var en = source.GetEnumerator())
            {
                if (!en.MoveNext())
                    yield break;

                yield return en.Current;
                TKey prevKey = keySelector(en.Current);

                while (en.MoveNext())
                {
                    TKey key = keySelector(en.Current);
                    if (!comparer.Equals(prevKey, key))
                    {
                        yield return en.Current;
                        prevKey = key;
                    }
                }
            }
        }

        #endregion
    }
}