mcs/class/System.Core/System.Linq/Enumerable.cs

   1 //
   2 // Enumerable.cs
   3 //
   4 // Authors:
   5 //  Marek Safar (marek.safar@gmail.com)
   6 //  Antonello Provenzano  <antonello@deveel.com>
   7 //  Alejandro Serrano "Serras" (trupill@yahoo.es)
   8 //  Jb Evain (jbevain@novell.com)
   9 //
  10 // Copyright (C) 2007 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 // precious: http://www.hookedonlinq.com
  33
  34 using System;
  35 using System.Collections;
  36 using System.Collections.Generic;
  37 using System.Collections.ObjectModel;
  38
  39 namespace System.Linq
  40 {
  41         public static class Enumerable
  42         {
  43                 #region Aggregate
  44
  45                 public static TSource Aggregate<TSource> (this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)
  46                 {
  47                         Check.SourceAndFunc (source, func);
  48
  49                         // custom foreach so that we can efficiently throw an exception
  50                         // if zero elements and treat the first element differently
  51                         using (var enumerator = source.GetEnumerator ()) {
  52                                 if (!enumerator.MoveNext ())
  53                                         throw new InvalidOperationException ("No elements in source list");
  54
  55                                 TSource folded = enumerator.Current;
  56                                 while (enumerator.MoveNext ())
  57                                         folded = func (folded, enumerator.Current);
  58                                 return folded;
  59                         }
  60                 }
  61
  62                 public static TAccumulate Aggregate<TSource, TAccumulate> (this IEnumerable<TSource> source,
  63                         TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
  64                 {
  65                         Check.SourceAndFunc (source, func);
  66
  67                         TAccumulate folded = seed;
  68                         foreach (TSource element in source)
  69                                 folded = func (folded, element);
  70
  71                         return folded;
  72                 }
  73
  74                 public static TResult Aggregate<TSource, TAccumulate, TResult> (this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
  75                 {
  76                         Check.SourceAndFunc (source, func);
  77                         if (resultSelector == null)
  78                                 throw new ArgumentNullException ("resultSelector");
  79
  80                         TAccumulate result = seed;
  81                         foreach (TSource e in source)
  82                                 result = func (result, e);
  83
  84                         return resultSelector (result);
  85                 }
  86
  87                 #endregion
  88
  89                 #region All
  90
  91                 public static bool All<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  92                 {
  93                         Check.SourceAndPredicate (source, predicate);
  94
  95                         foreach (TSource element in source)
  96                                 if (!predicate (element))
  97                                         return false;
  98
  99                         return true;
 100                 }
 101
 102                 #endregion
 103
 104                 #region Any
 105
 106                 public static bool Any<TSource> (this IEnumerable<TSource> source)
 107                 {
 108                         Check.Source (source);
 109
 110                         using (var enumerator = source.GetEnumerator ())
 111                                 return enumerator.MoveNext ();
 112                 }
 113
 114                 public static bool Any<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 115                 {
 116                         Check.SourceAndPredicate (source, predicate);
 117
 118                         foreach (TSource element in source)
 119                                 if (predicate (element))
 120                                         return true;
 121
 122                         return false;
 123                 }
 124
 125                 #endregion
 126
 127                 #region AsEnumerable
 128
 129                 public static IEnumerable<TSource> AsEnumerable<TSource> (this IEnumerable<TSource> source)
 130                 {
 131                         return source;
 132                 }
 133
 134                 #endregion
 135
 136                 #region Average
 137
 138                 public static double Average (this IEnumerable<int> source)
 139                 {
 140                         return Average (source, (a, b) => a + b, (a, b) => a / b);
 141                 }
 142
 143                 public static double Average (this IEnumerable<long> source)
 144                 {
 145                         return Average (source, (a, b) => a + b, (a, b) => a / b);
 146                 }
 147
 148                 public static double Average (this IEnumerable<double> source)
 149                 {
 150                         return Average (source, (a, b) => a + b, (a, b) => a / b);
 151                 }
 152
 153                 public static float Average (this IEnumerable<float> source)
 154                 {
 155                         return Average (source, (a, b) => a + b, (a, b) => a / b);
 156                 }
 157
 158                 public static decimal Average (this IEnumerable<decimal> source)
 159                 {
 160                         return Average (source, (a, b) => a + b, (a, b) => a / b);
 161                 }
 162
 163                 static TR Average<TA, TR> (this IEnumerable<TA> source, Func<TA, TA, TA> func, Func<TA, int, TR> result)
 164                 {
 165                         Check.Source (source);
 166
 167                         TA total = default (TA);
 168                         int counter = 0;
 169                         foreach (var element in source) {
 170                                 total = func (total, element);
 171                                 ++counter;
 172                         }
 173
 174                         if (counter == 0)
 175                                 throw new InvalidOperationException ();
 176
 177                         return result (total, counter);
 178                 }
 179
 180                 public static double? Average (this IEnumerable<int?> source)
 181                 {
 182                         Check.Source (source);
 183
 184                         bool onlyNull = true;
 185                         long sum = 0;
 186                         long counter = 0;
 187                         foreach (int? element in source) {
 188                                 if (element.HasValue) {
 189                                         onlyNull = false;
 190                                         sum += element.Value;
 191                                         counter++;
 192                                 }
 193                         }
 194                         return (onlyNull ? null : (double?) sum / (double?) counter);
 195                 }
 196
 197                 public static double? Average (this IEnumerable<long?> source)
 198                 {
 199                         Check.Source (source);
 200
 201                         bool onlyNull = true;
 202                         long sum = 0;
 203                         long counter = 0;
 204                         foreach (long? element in source) {
 205                                 if (element.HasValue) {
 206                                         onlyNull = false;
 207                                         sum += element.Value;
 208                                         counter++;
 209                                 }
 210                         }
 211                         return (onlyNull ? null : (double?) sum / (double?) counter);
 212                 }
 213
 214                 public static double? Average (this IEnumerable<double?> source)
 215                 {
 216                         Check.Source (source);
 217
 218                         bool onlyNull = true;
 219                         double sum = 0;
 220                         double counter = 0;
 221                         foreach (double? element in source) {
 222                                 if (element.HasValue) {
 223                                         onlyNull = false;
 224                                         sum += element.Value;
 225                                         counter++;
 226                                 }
 227                         }
 228                         return (onlyNull ? null : (double?) (sum / counter));
 229                 }
 230
 231                 public static decimal? Average (this IEnumerable<decimal?> source)
 232                 {
 233                         Check.Source (source);
 234
 235                         bool onlyNull = true;
 236                         decimal sum = 0;
 237                         decimal counter = 0;
 238                         foreach (decimal? element in source) {
 239                                 if (element.HasValue) {
 240                                         onlyNull = false;
 241                                         sum += element.Value;
 242                                         counter++;
 243                                 }
 244                         }
 245                         return (onlyNull ? null : (decimal?) (sum / counter));
 246                 }
 247
 248                 public static float? Average (this IEnumerable<float?> source)
 249                 {
 250                         Check.Source (source);
 251
 252                         float sum = 0;
 253                         float counter = 0;
 254                         foreach (float? element in source) {
 255                                 if (element.HasValue) {
 256                                         sum += element.Value;
 257                                         ++counter;
 258                                 }
 259                         }
 260
 261                         if (counter == 0)
 262                                 return null;
 263
 264                         return sum / counter;
 265                 }
 266
 267                 public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
 268                 {
 269                         Check.SourceAndSelector (source, selector);
 270
 271                         long sum = 0;
 272                         long counter = 0;
 273                         foreach (TSource item in source) {
 274                                 sum += selector (item);
 275                                 counter++;
 276                         }
 277
 278                         if (counter == 0)
 279                                 throw new InvalidOperationException ();
 280                         else
 281                                 return (double) sum / (double) counter;
 282                 }
 283
 284                 public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
 285                 {
 286                         Check.SourceAndSelector (source, selector);
 287
 288                         bool onlyNull = true;
 289                         long sum = 0;
 290                         long counter = 0;
 291                         foreach (TSource item in source) {
 292                                 int? element = selector (item);
 293                                 if (element.HasValue) {
 294                                         onlyNull = false;
 295                                         sum += element.Value;
 296                                         counter++;
 297                                 }
 298                         }
 299                         return (onlyNull ? null : (double?) sum / (double?) counter);
 300                 }
 301
 302                 public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
 303                 {
 304                         Check.SourceAndSelector (source, selector);
 305
 306                         long sum = 0;
 307                         long counter = 0;
 308                         foreach (TSource item in source) {
 309                                 sum += selector (item);
 310                                 counter++;
 311                         }
 312
 313                         if (counter == 0)
 314                                 throw new InvalidOperationException ();
 315                         else
 316                                 return (double) sum / (double) counter;
 317                 }
 318
 319                 public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
 320                 {
 321                         Check.SourceAndSelector (source, selector);
 322
 323                         bool onlyNull = true;
 324                         long sum = 0;
 325                         long counter = 0;
 326                         foreach (TSource item in source) {
 327                                 long? element = selector (item);
 328                                 if (element.HasValue) {
 329                                         onlyNull = false;
 330                                         sum += element.Value;
 331                                         counter++;
 332                                 }
 333                         }
 334                         return (onlyNull ? null : (double?) sum / (double?) counter);
 335                 }
 336
 337                 public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
 338                 {
 339                         Check.SourceAndSelector (source, selector);
 340
 341                         double sum = 0;
 342                         double counter = 0;
 343                         foreach (TSource item in source) {
 344                                 sum += selector (item);
 345                                 counter++;
 346                         }
 347
 348                         if (counter == 0)
 349                                 throw new InvalidOperationException ();
 350                         else
 351                                 return sum / counter;
 352                 }
 353
 354                 public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
 355                 {
 356                         Check.SourceAndSelector (source, selector);
 357
 358                         bool onlyNull = true;
 359                         double sum = 0;
 360                         double counter = 0;
 361                         foreach (TSource item in source) {
 362                                 double? element = selector (item);
 363                                 if (element.HasValue) {
 364                                         onlyNull = false;
 365                                         sum += element.Value;
 366                                         counter++;
 367                                 }
 368                         }
 369                         return (onlyNull ? null : (double?) (sum / counter));
 370                 }
 371
 372                 public static float Average<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
 373                 {
 374                         Check.SourceAndSelector (source, selector);
 375
 376                         float sum = 0;
 377                         float counter = 0;
 378                         foreach (TSource item in source) {
 379                                 sum += selector (item);
 380                                 ++counter;
 381                         }
 382
 383                         if (counter == 0)
 384                                 throw new InvalidOperationException ();
 385
 386                         return sum / counter;
 387                 }
 388
 389                 public static float? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
 390                 {
 391                         Check.SourceAndSelector (source, selector);
 392
 393                         float sum = 0;
 394                         float counter = 0;
 395                         foreach (TSource item in source) {
 396                                 float? value = selector (item);
 397                                 if (value.HasValue) {
 398                                         sum  += value.Value;
 399                                         ++counter;
 400                                 }
 401                         }
 402
 403                         if (counter == 0)
 404                                 throw new InvalidOperationException ();
 405
 406                         return sum / counter;
 407                 }
 408
 409                 public static decimal Average<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
 410                 {
 411                         Check.SourceAndSelector (source, selector);
 412
 413                         decimal sum = 0;
 414                         decimal counter = 0;
 415                         foreach (TSource item in source) {
 416                                 sum += selector (item);
 417                                 counter++;
 418                         }
 419
 420                         if (counter == 0)
 421                                 throw new InvalidOperationException ();
 422                         else
 423                                 return sum / counter;
 424                 }
 425
 426                 public static decimal? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
 427                 {
 428                         Check.SourceAndSelector (source, selector);
 429
 430                         bool onlyNull = true;
 431                         decimal sum = 0;
 432                         decimal counter = 0;
 433                         foreach (TSource item in source) {
 434                                 decimal? element = selector (item);
 435                                 if (element.HasValue) {
 436                                         onlyNull = false;
 437                                         sum += element.Value;
 438                                         counter++;
 439                                 }
 440                         }
 441                         return (onlyNull ? null : (decimal?) (sum / counter));
 442                 }
 443                 #endregion
 444
 445                 #region Cast
 446
 447                 public static IEnumerable<TResult> Cast<TResult> (this IEnumerable source)
 448                 {
 449                         Check.Source (source);
 450
 451                         return CreateCastIterator<TResult> (source);
 452                 }
 453
 454                 static IEnumerable<TResult> CreateCastIterator<TResult> (IEnumerable source)
 455                 {
 456                         foreach (object element in source)
 457                                 yield return (TResult) element;
 458                 }
 459
 460                 #endregion
 461
 462                 #region Concat
 463
 464                 public static IEnumerable<TSource> Concat<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
 465                 {
 466                         Check.FirstAndSecond (first, second);
 467
 468                         return CreateConcatIterator (first, second);
 469                 }
 470
 471                 static IEnumerable<TSource> CreateConcatIterator<TSource> (IEnumerable<TSource> first, IEnumerable<TSource> second)
 472                 {
 473                         foreach (TSource element in first)
 474                                 yield return element;
 475                         foreach (TSource element in second)
 476                                 yield return element;
 477                 }
 478
 479                 #endregion
 480
 481                 #region Contains
 482
 483                 public static bool Contains<TSource> (this IEnumerable<TSource> source, TSource value)
 484                 {
 485                         var collection = source as ICollection<TSource>;
 486                         if (collection != null)
 487                                 return collection.Contains (value);
 488
 489                         return Contains<TSource> (source, value, null);
 490                 }
 491
 492                 public static bool Contains<TSource> (this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
 493                 {
 494                         Check.Source (source);
 495
 496                         if (comparer == null)
 497                                 comparer = EqualityComparer<TSource>.Default;
 498
 499                         foreach (TSource e in source) {
 500                                 if (comparer.Equals (e, value))
 501                                         return true;
 502                         }
 503
 504                         return false;
 505                 }
 506                 #endregion
 507
 508                 #region Count
 509
 510                 public static int Count<TSource> (this IEnumerable<TSource> source)
 511                 {
 512                         Check.Source (source);
 513
 514                         var collection = source as ICollection<TSource>;
 515                         if (collection != null)
 516                                 return collection.Count;
 517
 518                         int counter = 0;
 519                         using (var enumerator = source.GetEnumerator ())
 520                                 while (enumerator.MoveNext ())
 521                                         counter++;
 522
 523                         return counter;
 524                 }
 525
 526                 public static int Count<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> selector)
 527                 {
 528                         Check.SourceAndSelector (source, selector);
 529
 530                         int counter = 0;
 531                         foreach (var element in source)
 532                                 if (selector (element))
 533                                         counter++;
 534
 535                         return counter;
 536                 }
 537
 538                 #endregion
 539
 540                 #region DefaultIfEmpty
 541
 542                 public static IEnumerable<TSource> DefaultIfEmpty<TSource> (this IEnumerable<TSource> source)
 543                 {
 544                         return DefaultIfEmpty (source, default (TSource));
 545                 }
 546
 547                 public static IEnumerable<TSource> DefaultIfEmpty<TSource> (this IEnumerable<TSource> source, TSource defaultValue)
 548                 {
 549                         Check.Source (source);
 550
 551                         return CreateDefaultIfEmptyIterator (source, defaultValue);
 552                 }
 553
 554                 static IEnumerable<TSource> CreateDefaultIfEmptyIterator<TSource> (IEnumerable<TSource> source, TSource defaultValue)
 555                 {
 556                         bool empty = true;
 557                         foreach (TSource item in source) {
 558                                 empty = false;
 559                                 yield return item;
 560                         }
 561
 562                         if (empty)
 563                                 yield return defaultValue;
 564                 }
 565
 566                 #endregion
 567
 568                 #region Distinct
 569
 570                 public static IEnumerable<TSource> Distinct<TSource> (this IEnumerable<TSource> source)
 571                 {
 572                         return Distinct<TSource> (source, null);
 573                 }
 574
 575                 public static IEnumerable<TSource> Distinct<TSource> (this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
 576                 {
 577                         Check.Source (source);
 578
 579                         if (comparer == null)
 580                                 comparer = EqualityComparer<TSource>.Default;
 581
 582                         return CreateDistinctIterator (source, comparer);
 583                 }
 584
 585                 static IEnumerable<TSource> CreateDistinctIterator<TSource> (IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
 586                 {
 587                         var items = new HashSet<TSource> (comparer);
 588                         foreach (var element in source) {
 589                                 if (! items.Contains (element)) {
 590                                         items.Add (element);
 591                                         yield return element;
 592                                 }
 593                         }
 594                 }
 595
 596                 #endregion
 597
 598                 #region ElementAt
 599
 600                 public static TSource ElementAt<TSource> (this IEnumerable<TSource> source, int index)
 601                 {
 602                         Check.Source (source);
 603                         if (index < 0)
 604                                 throw new ArgumentOutOfRangeException ();
 605
 606                         var list = source as IList<TSource>;
 607                         if (list != null)
 608                                 return list [index];
 609
 610                         int counter = 0;
 611                         foreach (var element in source) {
 612                                 if (counter == index)
 613                                         return element;
 614                                 counter++;
 615                         }
 616
 617                         throw new ArgumentOutOfRangeException ();
 618                 }
 619
 620                 #endregion
 621
 622                 #region ElementAtOrDefault
 623
 624                 public static TSource ElementAtOrDefault<TSource> (this IEnumerable<TSource> source, int index)
 625                 {
 626                         Check.Source (source);
 627                         if (index < 0)
 628                                 return default (TSource);
 629
 630                         var list = source as IList<TSource>;
 631                         if (list != null)
 632                                 return index < list.Count ? list [index] : default (TSource);
 633
 634                         int counter = 0;
 635                         foreach (TSource element in source) {
 636                                 if (counter == index)
 637                                         return element;
 638                                 counter++;
 639                         }
 640
 641                         return default (TSource);
 642                 }
 643
 644                 #endregion
 645
 646                 #region Empty
 647
 648                 public static IEnumerable<TResult> Empty<TResult> ()
 649                 {
 650                         return new TResult [0];
 651                 }
 652
 653                 #endregion
 654
 655                 #region Except
 656
 657                 public static IEnumerable<TSource> Except<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
 658                 {
 659                         return Except (first, second, null);
 660                 }
 661
 662                 public static IEnumerable<TSource> Except<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
 663                 {
 664                         Check.FirstAndSecond (first, second);
 665
 666                         if (comparer == null)
 667                                 comparer = EqualityComparer<TSource>.Default;
 668
 669                         return CreateExceptIterator (first, second, comparer);
 670                 }
 671
 672                 static IEnumerable<TSource> CreateExceptIterator<TSource> (IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
 673                 {
 674                         var items = new HashSet<TSource> (Distinct (second));
 675                         foreach (TSource element in first) {
 676                                 if (! items.Contains (element, comparer))
 677                                         yield return element;
 678                         }
 679                 }
 680
 681                 #endregion
 682
 683                 #region First
 684
 685                 public static TSource First<TSource> (this IEnumerable<TSource> source)
 686                 {
 687                         Check.Source (source);
 688
 689                         foreach (TSource element in source)
 690                                 return element;
 691
 692                         throw new InvalidOperationException ();
 693                 }
 694
 695
 696                 public static TSource First<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 697                 {
 698                         Check.SourceAndPredicate (source, predicate);
 699
 700                         foreach (TSource element in source) {
 701                                 if (predicate (element))
 702                                         return element;
 703                         }
 704
 705                         throw new InvalidOperationException ();
 706                 }
 707
 708                 #endregion
 709
 710                 #region FirstOrDefault
 711
 712                 public static TSource FirstOrDefault<TSource> (this IEnumerable<TSource> source)
 713                 {
 714                         Check.Source (source);
 715
 716                         foreach (TSource element in source)
 717                                 return element;
 718
 719                         return default (TSource);
 720                 }
 721
 722
 723                 public static TSource FirstOrDefault<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 724                 {
 725                         Check.SourceAndPredicate (source, predicate);
 726
 727                         foreach (TSource element in source) {
 728                                 if (predicate (element))
 729                                         return element;
 730                         }
 731
 732                         return default (TSource);
 733                 }
 734
 735                 #endregion
 736
 737                 #region GroupBy
 738
 739                 private static List<T> ContainsGroup<K, T> (
 740                                 Dictionary<K, List<T>> items, K key, IEqualityComparer<K> comparer)
 741                 {
 742                         IEqualityComparer<K> comparerInUse = (comparer ?? EqualityComparer<K>.Default);
 743                         foreach (KeyValuePair<K, List<T>> value in items) {
 744                                 if (comparerInUse.Equals (value.Key, key))
 745                                         return value.Value;
 746                         }
 747                         return null;
 748                 }
 749
 750
 751                 public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IEnumerable<TSource> source,
 752                         Func<TSource, TKey> keySelector)
 753                 {
 754                         return GroupBy<TSource, TKey> (source, keySelector, null);
 755                 }
 756
 757                 public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IEnumerable<TSource> source,
 758                         Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
 759                 {
 760                         Check.SourceAndKeySelector (source, keySelector);
 761
 762                         Dictionary<TKey, List<TSource>> groups = new Dictionary<TKey, List<TSource>> ();
 763                         List<TSource> nullList = new List<TSource> ();
 764                         int counter = 0;
 765                         int nullCounter = -1;
 766
 767                         foreach (TSource element in source) {
 768                                 TKey key = keySelector (element);
 769                                 if (key == null) {
 770                                         nullList.Add (element);
 771                                         if (nullCounter == -1) {
 772                                                 nullCounter = counter;
 773                                                 counter++;
 774                                         }
 775                                 } else {
 776                                         List<TSource> group = ContainsGroup<TKey, TSource> (groups, key, comparer);
 777                                         if (group == null) {
 778                                                 group = new List<TSource> ();
 779                                                 groups.Add (key, group);
 780                                                 counter++;
 781                                         }
 782                                         group.Add (element);
 783                                 }
 784                         }
 785
 786                         counter = 0;
 787                         foreach (KeyValuePair<TKey, List<TSource>> group in groups) {
 788                                 if (counter == nullCounter) {
 789                                         Grouping<TKey, TSource> nullGroup = new Grouping<TKey, TSource> (default (TKey), nullList);
 790                                         yield return nullGroup;
 791                                         counter++;
 792                                 }
 793                                 Grouping<TKey, TSource> grouping = new Grouping<TKey, TSource> (group.Key, group.Value);
 794                                 yield return grouping;
 795                                 counter++;
 796                         }
 797                 }
 798
 799
 800                 public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IEnumerable<TSource> source,
 801                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
 802                 {
 803                         return GroupBy<TSource, TKey, TElement> (source, keySelector, elementSelector, null);
 804                 }
 805
 806                 public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IEnumerable<TSource> source,
 807                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
 808                 {
 809                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
 810
 811                         Dictionary<TKey, List<TElement>> groups = new Dictionary<TKey, List<TElement>> ();
 812                         List<TElement> nullList = new List<TElement> ();
 813                         int counter = 0;
 814                         int nullCounter = -1;
 815
 816                         foreach (TSource item in source) {
 817                                 TKey key = keySelector (item);
 818                                 TElement element = elementSelector (item);
 819                                 if (key == null) {
 820                                         nullList.Add (element);
 821                                         if (nullCounter == -1) {
 822                                                 nullCounter = counter;
 823                                                 counter++;
 824                                         }
 825                                 } else {
 826                                         List<TElement> group = ContainsGroup<TKey, TElement> (groups, key, comparer);
 827                                         if (group == null) {
 828                                                 group = new List<TElement> ();
 829                                                 groups.Add (key, group);
 830                                                 counter++;
 831                                         }
 832                                         group.Add (element);
 833                                 }
 834                         }
 835
 836                         counter = 0;
 837                         foreach (KeyValuePair<TKey, List<TElement>> group in groups) {
 838                                 if (counter == nullCounter) {
 839                                         Grouping<TKey, TElement> nullGroup = new Grouping<TKey, TElement> (default (TKey), nullList);
 840                                         yield return nullGroup;
 841                                         counter++;
 842                                 }
 843                                 Grouping<TKey, TElement> grouping = new Grouping<TKey, TElement> (group.Key, group.Value);
 844                                 yield return grouping;
 845                                 counter++;
 846                         }
 847                 }
 848
 849                 public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult> (this IEnumerable<TSource> source,
 850                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector,
 851                         Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
 852                 {
 853                         return GroupBy (source, keySelector, elementSelector, resultSelector, null);
 854                 }
 855
 856                 [MonoTODO]
 857                 public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult> (this IEnumerable<TSource> source,
 858                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector,
 859                         Func<TKey, IEnumerable<TElement>, TResult> resultSelector,
 860                         IEqualityComparer<TKey> comparer)
 861                 {
 862                         throw new NotImplementedException ();
 863                 }
 864
 865                 public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult> (this IEnumerable<TSource> source,
 866                         Func<TSource, TKey> keySelector,
 867                         Func<TKey, IEnumerable<TSource>, TResult> resultSelector)
 868                 {
 869                         return GroupBy (source, keySelector, resultSelector, null);
 870                 }
 871
 872                 [MonoTODO]
 873                 public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult> (this IEnumerable<TSource> source,
 874                         Func<TSource, TKey> keySelector,
 875                         Func<TKey, IEnumerable<TSource>, TResult> resultSelector,
 876                         IEqualityComparer<TKey> comparer)
 877                 {
 878                         throw new NotImplementedException ();
 879                 }
 880
 881                 #endregion
 882
 883                 # region GroupJoin
 884
 885                 public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer,
 886                         IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
 887                         Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
 888                 {
 889                         return GroupJoin (outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
 890                 }
 891
 892                 public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer,
 893                         IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
 894                         Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector,
 895                         IEqualityComparer<TKey> comparer)
 896                 {
 897                         Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
 898
 899                         if (comparer == null)
 900                                 comparer = EqualityComparer<TKey>.Default;
 901
 902                         ILookup<TKey, TInner> innerKeys = ToLookup<TInner, TKey> (inner, innerKeySelector, comparer);
 903                         /*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
 904                         foreach (U element in inner)
 905                         {
 906                                         K innerKey = innerKeySelector (element);
 907                                         if (!innerKeys.ContainsKey (innerKey))
 908                                                         innerKeys.Add (innerKey, new List<U> ());
 909                                         innerKeys[innerKey].Add (element);
 910                         }*/
 911
 912                         foreach (TOuter element in outer) {
 913                                 TKey outerKey = outerKeySelector (element);
 914                                 if (innerKeys.Contains (outerKey))
 915                                         yield return resultSelector (element, innerKeys [outerKey]);
 916                                 else
 917                                         yield return resultSelector (element, Empty<TInner> ());
 918                         }
 919                 }
 920
 921                 #endregion
 922
 923                 #region Intersect
 924
 925                 public static IEnumerable<TSource> Intersect<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
 926                 {
 927                         return Intersect (first, second, null);
 928                 }
 929
 930                 public static IEnumerable<TSource> Intersect<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
 931                 {
 932                         Check.FirstAndSecond (first, second);
 933
 934                         if (comparer == null)
 935                                 comparer = EqualityComparer<TSource>.Default;
 936
 937                         return CreateIntersectIterator (first, second, comparer);
 938                 }
 939
 940                 static IEnumerable<TSource> CreateIntersectIterator<TSource> (IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
 941                 {
 942                         var items = new HashSet<TSource> (second, comparer);
 943                         foreach (TSource element in first) {
 944                                 if (items.Contains (element))
 945                                         yield return element;
 946                         }
 947                 }
 948
 949                 #endregion
 950
 951                 # region Join
 952
 953                 public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer,
 954                         IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
 955                         Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
 956                 {
 957                         Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
 958
 959                         if (comparer == null)
 960                                 comparer = EqualityComparer<TKey>.Default;
 961
 962                         ILookup<TKey, TInner> innerKeys = ToLookup<TInner, TKey> (inner, innerKeySelector, comparer);
 963                         /*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
 964                         foreach (U element in inner)
 965                         {
 966                                         K innerKey = innerKeySelector (element);
 967                                         if (!innerKeys.ContainsKey (innerKey))
 968                                                         innerKeys.Add (innerKey, new List<U> ());
 969                                         innerKeys[innerKey].Add (element);
 970                         }*/
 971
 972                         foreach (TOuter element in outer) {
 973                                 TKey outerKey = outerKeySelector (element);
 974                                 if (innerKeys.Contains (outerKey)) {
 975                                         foreach (TInner innerElement in innerKeys [outerKey])
 976                                                 yield return resultSelector (element, innerElement);
 977                                 }
 978                         }
 979                 }
 980
 981                 public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer,
 982                         IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
 983                         Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
 984                 {
 985                         return Join<TOuter, TInner, TKey, TResult> (outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
 986                 }
 987
 988                 # endregion
 989
 990                 #region Last
 991
 992                 public static TSource Last<TSource> (this IEnumerable<TSource> source)
 993                 {
 994                         Check.Source (source);
 995
 996                         bool noElements = true;
 997                         TSource lastElement = default (TSource);
 998                         foreach (TSource element in source) {
 999                                 if (noElements) noElements = false;
1000                                 lastElement = element;
1001                         }
1002
1003                         if (!noElements)
1004                                 return lastElement;
1005                         else
1006                                 throw new InvalidOperationException ();
1007                 }
1008
1009                 public static TSource Last<TSource> (this IEnumerable<TSource> source,
1010                                 Func<TSource, bool> predicate)
1011                 {
1012                         Check.SourceAndPredicate (source, predicate);
1013
1014                         bool noElements = true;
1015                         TSource lastElement = default (TSource);
1016                         foreach (TSource element in source) {
1017                                 if (predicate (element)) {
1018                                         if (noElements) noElements = false;
1019                                         lastElement = element;
1020                                 }
1021                         }
1022
1023                         if (!noElements)
1024                                 return lastElement;
1025                         else
1026                                 throw new InvalidOperationException ();
1027                 }
1028
1029                 #endregion
1030
1031                 #region LastOrDefault
1032
1033                 public static TSource LastOrDefault<TSource> (this IEnumerable<TSource> source)
1034                 {
1035                         Check.Source (source);
1036
1037                         var list = source as IList<TSource>;
1038                         if (list != null)
1039                                 return list.Count > 0 ? list [list.Count - 1] : default (TSource);
1040
1041                         TSource lastElement = default (TSource);
1042                         foreach (TSource element in source)
1043                                 lastElement = element;
1044
1045                         return lastElement;
1046                 }
1047
1048                 public static TSource LastOrDefault<TSource> (this IEnumerable<TSource> source,
1049                         Func<TSource, bool> predicate)
1050                 {
1051                         Check.SourceAndPredicate (source, predicate);
1052
1053                         TSource lastElement = default (TSource);
1054                         foreach (TSource element in source) {
1055                                 if (predicate (element))
1056                                         lastElement = element;
1057                         }
1058
1059                         return lastElement;
1060                 }
1061
1062                 #endregion
1063
1064                 #region LongCount
1065                 public static long LongCount<TSource> (this IEnumerable<TSource> source)
1066                 {
1067                         Check.Source (source);
1068
1069                         long counter = 0;
1070                         using (var enumerator = source.GetEnumerator ())
1071                                 while (enumerator.MoveNext ())
1072                                         counter++;
1073
1074                         return counter;
1075                 }
1076
1077                 public static long LongCount<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> selector)
1078                 {
1079                         Check.SourceAndSelector (source, selector);
1080
1081                         long counter = 0;
1082                         foreach (TSource element in source)
1083                                 if (selector (element))
1084                                         counter++;
1085
1086                         return counter;
1087                 }
1088
1089                 #endregion
1090
1091                 #region Max
1092
1093                 public static int Max (this IEnumerable<int> source)
1094                 {
1095                         return Iterate (source, int.MinValue, (a, b) => a > b);
1096                 }
1097
1098                 public static long Max (this IEnumerable<long> source)
1099                 {
1100                         return Iterate (source, long.MinValue, (a, b) => a > b);
1101                 }
1102
1103                 public static double Max (this IEnumerable<double> source)
1104                 {
1105                         return Iterate (source, double.MinValue, (a, b) => a > b);
1106                 }
1107
1108                 public static float Max (this IEnumerable<float> source)
1109                 {
1110                         return Iterate (source, float.MinValue, (a, b) => a > b);
1111                 }
1112
1113                 public static decimal Max (this IEnumerable<decimal> source)
1114                 {
1115                         return Iterate (source, decimal.MinValue, (a, b) => a > b);
1116                 }
1117
1118                 static T Iterate<T> (IEnumerable<T> source, T initValue, Func<T, T, bool> selector)
1119                 {
1120                         Check.SourceAndSelector (source, selector);
1121
1122                         int counter = 0;
1123                         foreach (var element in source) {
1124                                 if (selector (element, initValue))
1125                                         initValue = element;
1126                                 ++counter;
1127                         }
1128
1129                         if (counter == 0)
1130                                 throw new InvalidOperationException ();
1131
1132                         return initValue;
1133                 }
1134
1135                 public static int? Max (this IEnumerable<int?> source)
1136                 {
1137                         return IterateNullable (source, int.MinValue, (a, b) => a > b);
1138                 }
1139
1140                 public static long? Max (this IEnumerable<long?> source)
1141                 {
1142                         return IterateNullable (source, long.MinValue, (a, b) => a > b);
1143                 }
1144
1145                 public static double? Max (this IEnumerable<double?> source)
1146                 {
1147                         return IterateNullable (source, double.MinValue, (a, b) => a > b);
1148                 }
1149
1150                 public static float? Max (this IEnumerable<float?> source)
1151                 {
1152                         return IterateNullable (source, float.MinValue, (a, b) => a > b);
1153                 }
1154
1155                 public static decimal? Max (this IEnumerable<decimal?> source)
1156                 {
1157                         return IterateNullable (source, decimal.MinValue, (a, b) => a > b);
1158                 }
1159
1160                 static T? IterateNullable<T> (IEnumerable<T?> source, T initValue, Func<T?, T?, bool> selector) where T : struct
1161                 {
1162                         Check.SourceAndSelector (source, selector);
1163
1164                         int counter = 0;
1165                         T? value = initValue;
1166                         foreach (var element in source) {
1167                                 if (!element.HasValue)
1168                                         continue;
1169
1170                                 if (selector (element.Value, value))
1171                                         value = element;
1172                                 ++counter;
1173                         }
1174
1175                         if (counter == 0)
1176                                 return null;
1177
1178                         return value;
1179                 }
1180
1181                 public static TSource Max<TSource> (this IEnumerable<TSource> source)
1182                 {
1183                         Check.Source (source);
1184
1185                         bool notAssigned = true;
1186                         TSource maximum = default (TSource);
1187                         int counter = 0;
1188                         foreach (TSource element in source) {
1189                                 if (notAssigned) {
1190                                         maximum = element;
1191                                         notAssigned = false;
1192                                 } else {
1193                                         int comparison;
1194                                         if (element is IComparable<TSource>)
1195                                                 comparison = ((IComparable<TSource>) element).CompareTo (maximum);
1196                                         else if (element is System.IComparable)
1197                                                 comparison = ((System.IComparable) element).CompareTo (maximum);
1198                                         else
1199                                                 throw new ArgumentNullException ();
1200
1201                                         if (comparison > 0)
1202                                                 maximum = element;
1203                                 }
1204                                 counter++;
1205                         }
1206
1207                         if (counter == 0)
1208                                 throw new InvalidOperationException ();
1209                         else
1210                                 return maximum;
1211                 }
1212
1213                 public static int Max<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
1214                 {
1215                         return Iterate (source, int.MinValue, (a, b) => {
1216                                 var v = selector (a); return v > b ? v : b;
1217                         });
1218                 }
1219
1220                 public static long Max<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
1221                 {
1222                         return Iterate (source, long.MinValue, (a, b) => {
1223                                 var v = selector (a); return v > b ? v : b;
1224                         });
1225                 }
1226
1227                 public static double Max<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
1228                 {
1229                         return Iterate (source, double.MinValue, (a, b) => {
1230                                 var v = selector (a); return v > b ? v : b;
1231                         });
1232                 }
1233
1234                 public static float Max<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
1235                 {
1236                         return Iterate (source, float.MinValue, (a, b) => {
1237                                 var v = selector (a); return v > b ? v : b;
1238                         });
1239                 }
1240
1241                 public static decimal Max<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
1242                 {
1243                         return Iterate (source, decimal.MinValue, (a, b) => {
1244                                 var v = selector (a); return v > b ? v : b;
1245                         });
1246                 }
1247
1248                 static U Iterate<T, U> (IEnumerable<T> source, U initValue, Func<T, U, U> selector)
1249                 {
1250                         Check.SourceAndSelector (source, selector);
1251
1252                         int counter = 0;
1253                         foreach (var element in source) {
1254                                 initValue = selector (element, initValue);
1255                                 ++counter;
1256                         }
1257
1258                         if (counter == 0)
1259                                 throw new InvalidOperationException ();
1260
1261                         return initValue;
1262                 }
1263
1264                 static U? IterateNullable<T, U> (IEnumerable<T> source, U initialValue, Func<T, U?, U?> selector) where U : struct
1265                 {
1266                         Check.SourceAndSelector (source, selector);
1267
1268                         int counter = 0;
1269                         U? value = initialValue;
1270                         foreach (var element in source) {
1271                                 value = selector (element, value);
1272                                 if (!value.HasValue)
1273                                         continue;
1274
1275                                 ++counter;
1276                         }
1277
1278                         if (counter == 0)
1279                                 return null;
1280
1281                         return value;
1282                 }
1283
1284                 public static int? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
1285                 {
1286                         return IterateNullable (source, int.MinValue, (a, b) => {
1287                                 var v = selector (a); return v > b ? v : b;
1288                         });
1289                 }
1290
1291                 public static long? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
1292                 {
1293                         return IterateNullable (source, long.MinValue, (a, b) => {
1294                                 var v = selector (a); return v > b ? v : b;
1295                         });
1296                 }
1297
1298                 public static double? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
1299                 {
1300                         return IterateNullable (source, double.MinValue, (a, b) => {
1301                                 var v = selector (a); return v > b ? v : b;
1302                         });
1303                 }
1304
1305                 public static float? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
1306                 {
1307                         return IterateNullable (source, float.MinValue, (a, b) => {
1308                                 var v = selector (a); return v > b ? v : b;
1309                         });
1310                 }
1311
1312                 public static decimal? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
1313                 {
1314                         return IterateNullable (source, decimal.MinValue, (a, b) => {
1315                                 var v = selector (a); return v > b ? v : b;
1316                         });
1317                 }
1318
1319                 public static TResult Max<TSource, TResult> (this IEnumerable<TSource> source,
1320                                 Func<TSource, TResult> selector)
1321                 {
1322                         Check.SourceAndSelector (source, selector);
1323
1324                         bool notAssigned = true;
1325                         TResult maximum = default (TResult);
1326                         int counter = 0;
1327                         foreach (TSource item in source) {
1328                                 TResult element = selector (item);
1329                                 if (notAssigned) {
1330                                         maximum = element;
1331                                         notAssigned = false;
1332                                 } else {
1333                                         int comparison;
1334                                         if (element is IComparable<TResult>)
1335                                                 comparison = ((IComparable<TResult>) element).CompareTo (maximum);
1336                                         else if (element is System.IComparable)
1337                                                 comparison = ((System.IComparable) element).CompareTo (maximum);
1338                                         else
1339                                                 throw new ArgumentNullException ();
1340
1341                                         if (comparison > 0)
1342                                                 maximum = element;
1343                                 }
1344                                 counter++;
1345                         }
1346
1347                         if (counter == 0)
1348                                 throw new InvalidOperationException ();
1349                         else
1350                                 return maximum;
1351                 }
1352
1353                 #endregion
1354
1355                 #region Min
1356
1357                 public static int Min (this IEnumerable<int> source)
1358                 {
1359                         return Iterate (source, int.MaxValue, (a, b) => a < b);
1360                 }
1361
1362                 public static long Min (this IEnumerable<long> source)
1363                 {
1364                         return Iterate (source, long.MaxValue, (a, b) => a < b);
1365                 }
1366
1367                 public static double Min (this IEnumerable<double> source)
1368                 {
1369                         return Iterate (source, double.MaxValue, (a, b) => a < b);
1370                 }
1371
1372                 public static float Min (this IEnumerable<float> source)
1373                 {
1374                         return Iterate (source, float.MaxValue, (a, b) => a < b);
1375                 }
1376
1377                 public static decimal Min (this IEnumerable<decimal> source)
1378                 {
1379                         return Iterate (source, decimal.MaxValue, (a, b) => a < b);
1380                 }
1381
1382                 public static int? Min (this IEnumerable<int?> source)
1383                 {
1384                         return IterateNullable (source, int.MaxValue, (a, b) => a < b);
1385                 }
1386
1387                 public static long? Min (this IEnumerable<long?> source)
1388                 {
1389                         return IterateNullable (source, long.MaxValue, (a, b) => a < b);
1390                 }
1391
1392                 public static double? Min (this IEnumerable<double?> source)
1393                 {
1394                         return IterateNullable (source, double.MaxValue, (a, b) => a < b);
1395                 }
1396
1397                 public static float? Min (this IEnumerable<float?> source)
1398                 {
1399                         return IterateNullable (source, float.MaxValue, (a, b) => a < b);
1400                 }
1401
1402                 public static decimal? Min (this IEnumerable<decimal?> source)
1403                 {
1404                         return IterateNullable (source, decimal.MaxValue, (a, b) => a < b);
1405                 }
1406
1407                 public static TSource Min<TSource> (this IEnumerable<TSource> source)
1408                 {
1409                         Check.Source (source);
1410
1411                         bool notAssigned = true;
1412                         TSource minimum = default (TSource);
1413                         int counter = 0;
1414                         foreach (TSource element in source) {
1415                                 if (notAssigned) {
1416                                         minimum = element;
1417                                         notAssigned = false;
1418                                 } else {
1419                                         int comparison;
1420                                         if (element is IComparable<TSource>)
1421                                                 comparison = ((IComparable<TSource>) element).CompareTo (minimum);
1422                                         else if (element is System.IComparable)
1423                                                 comparison = ((System.IComparable) element).CompareTo (minimum);
1424                                         else
1425                                                 throw new ArgumentNullException ();
1426
1427                                         if (comparison < 0)
1428                                                 minimum = element;
1429                                 }
1430                                 counter++;
1431                         }
1432
1433                         if (counter == 0)
1434                                 throw new InvalidOperationException ();
1435                         else
1436                                 return minimum;
1437                 }
1438
1439                 public static int Min<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
1440                 {
1441                         return Iterate (source, int.MaxValue, (a, b) => {
1442                                 var v = selector (a); return v < b ? v : b;
1443                         });
1444                 }
1445
1446                 public static long Min<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
1447                 {
1448                         return Iterate (source, long.MaxValue, (a, b) => {
1449                                 var v = selector (a); return v < b ? v : b;
1450                         });
1451                 }
1452
1453                 public static double Min<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
1454                 {
1455                         return Iterate (source, double.MaxValue, (a, b) => {
1456                                 var v = selector (a); return v < b ? v : b;
1457                         });
1458                 }
1459
1460                 public static float Min<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
1461                 {
1462                         return Iterate (source, float.MaxValue, (a, b) => {
1463                                 var v = selector (a); return v < b ? v : b;
1464                         });
1465                 }
1466
1467                 public static decimal Min<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
1468                 {
1469                         return Iterate (source, decimal.MaxValue, (a, b) => {
1470                                 var v = selector (a); return v < b ? v : b;
1471                         });
1472                 }
1473
1474                 public static int? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
1475                 {
1476                         return IterateNullable (source, int.MaxValue, (a, b) => {
1477                                 var v = selector (a); return v < b ? v : b;
1478                         });
1479                 }
1480
1481                 public static long? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
1482                 {
1483                         return IterateNullable (source, long.MaxValue, (a, b) => {
1484                                 var v = selector (a); return v < b ? v : b;
1485                         });
1486                 }
1487
1488                 public static double? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
1489                 {
1490                         return IterateNullable (source, float.MaxValue, (a, b) => {
1491                                 var v = selector (a); return v < b ? v : b;
1492                         });
1493                 }
1494
1495                 public static double? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
1496                 {
1497                         return IterateNullable (source, double.MaxValue, (a, b) => {
1498                                 var v = selector (a); return v < b ? v : b;
1499                         });
1500                 }
1501
1502                 public static decimal? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
1503                 {
1504                         return IterateNullable (source, decimal.MaxValue, (a, b) => {
1505                                 var v = selector (a); return v < b ? v : b;
1506                         });
1507                 }
1508
1509                 public static TResult Min<TSource, TResult> (this IEnumerable<TSource> source,
1510                                 Func<TSource, TResult> selector)
1511                 {
1512                         Check.SourceAndSelector (source, selector);
1513
1514                         bool notAssigned = true;
1515                         TResult minimum = default (TResult);
1516                         int counter = 0;
1517                         foreach (TSource item in source) {
1518                                 TResult element = selector (item);
1519                                 if (notAssigned) {
1520                                         minimum = element;
1521                                         notAssigned = false;
1522                                 } else {
1523                                         int comparison;
1524                                         if (element is IComparable<TResult>)
1525                                                 comparison = ((IComparable<TResult>) element).CompareTo (minimum);
1526                                         else if (element is System.IComparable)
1527                                                 comparison = ((System.IComparable) element).CompareTo (minimum);
1528                                         else
1529                                                 throw new ArgumentNullException ();
1530
1531                                         if (comparison < 0)
1532                                                 minimum = element;
1533                                 }
1534                                 counter++;
1535                         }
1536
1537                         if (counter == 0)
1538                                 throw new InvalidOperationException ();
1539                         else
1540                                 return minimum;
1541                 }
1542
1543                 #endregion
1544
1545                 #region OfType
1546
1547                 public static IEnumerable<TResult> OfType<TResult> (this IEnumerable source)
1548                 {
1549                         Check.Source (source);
1550
1551                         return CreateOfTypeIterator<TResult> (source);
1552                 }
1553
1554                 static IEnumerable<TResult> CreateOfTypeIterator<TResult> (IEnumerable source)
1555                 {
1556                         foreach (object element in source)
1557                                 if (element is TResult)
1558                                         yield return (TResult) element;
1559                 }
1560
1561                 #endregion
1562
1563                 #region OrderBy
1564
1565                 public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source,
1566                                 Func<TSource, TKey> keySelector)
1567                 {
1568                         return OrderBy<TSource, TKey> (source, keySelector, null);
1569                 }
1570
1571
1572                 public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source,
1573                                 Func<TSource, TKey> keySelector,
1574                                 IComparer<TKey> comparer)
1575                 {
1576                         Check.SourceAndKeySelector (source, keySelector);
1577
1578                         return new InternalOrderedSequence<TSource, TKey> (
1579                                         source, keySelector, comparer, false);
1580                 }
1581
1582                 #endregion
1583
1584                 #region OrderByDescending
1585
1586                 public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source,
1587                                 Func<TSource, TKey> keySelector)
1588                 {
1589                         return OrderByDescending<TSource, TKey> (source, keySelector, null);
1590                 }
1591
1592
1593                 public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source,
1594                                 Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
1595                 {
1596                         Check.SourceAndKeySelector (source, keySelector);
1597
1598                         return new InternalOrderedSequence<TSource, TKey> (
1599                                         source, keySelector, comparer, true);
1600                 }
1601
1602                 #endregion
1603
1604                 #region Range
1605
1606                 public static IEnumerable<int> Range (int start, int count)
1607                 {
1608                         if (count < 0)
1609                                 throw new ArgumentOutOfRangeException ("count");
1610
1611                         long upto = ((long) start + count) - 1;
1612
1613                         if (upto > int.MaxValue)
1614                                 throw new ArgumentOutOfRangeException ();
1615
1616                         return CreateRangeIterator (start, (int) upto);
1617                 }
1618
1619                 static IEnumerable<int> CreateRangeIterator (int start, int upto)
1620                 {
1621                         for (int i = start; i <= upto; i++)
1622                                 yield return i;
1623                 }
1624
1625                 #endregion
1626
1627                 #region Repeat
1628
1629                 public static IEnumerable<TResult> Repeat<TResult> (TResult element, int count)
1630                 {
1631                         if (count < 0)
1632                                 throw new ArgumentOutOfRangeException ();
1633
1634                         return CreateRepeatIterator (element, count);
1635                 }
1636
1637                 static IEnumerable<TResult> CreateRepeatIterator<TResult> (TResult element, int count)
1638                 {
1639                         for (int i = 0; i < count; i++)
1640                                 yield return element;
1641                 }
1642
1643                 #endregion
1644
1645
1646                 #region Reverse
1647
1648                 public static IEnumerable<TSource> Reverse<TSource> (this IEnumerable<TSource> source)
1649                 {
1650                         Check.Source (source);
1651
1652                         return CreateReverseIterator (source);
1653                 }
1654
1655                 static IEnumerable<TSource> CreateReverseIterator<TSource> (IEnumerable<TSource> source)
1656                 {
1657                         var list = new List<TSource> (source);
1658                         list.Reverse ();
1659                         return list;
1660                 }
1661
1662                 #endregion
1663
1664                 #region Select
1665
1666                 public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
1667                 {
1668                         Check.SourceAndSelector (source, selector);
1669
1670                         return CreateSelectIterator (source, selector);
1671                 }
1672
1673                 static IEnumerable<TResult> CreateSelectIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, TResult> selector)
1674                 {
1675                         foreach (TSource element in source)
1676                                 yield return selector (element);
1677                 }
1678
1679                 public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
1680                 {
1681                         Check.SourceAndSelector (source, selector);
1682
1683                         return CreateSelectIterator (source, selector);
1684                 }
1685
1686                 static IEnumerable<TResult> CreateSelectIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
1687                 {
1688                         int counter = 0;
1689                         foreach (TSource element in source) {
1690                                 yield return selector (element, counter);
1691                                 counter++;
1692                         }
1693                 }
1694
1695                 #endregion
1696
1697                 #region SelectMany
1698
1699                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
1700                 {
1701                         Check.SourceAndSelector (source, selector);
1702
1703                         return CreateSelectManyIterator (source, selector);
1704                 }
1705
1706                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
1707                 {
1708                         foreach (TSource element in source)
1709                                 foreach (TResult item in selector (element))
1710                                         yield return item;
1711                 }
1712
1713                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
1714                 {
1715                         Check.SourceAndSelector (source, selector);
1716
1717                         return CreateSelectManyIterator (source, selector);
1718                 }
1719
1720                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
1721                 {
1722                         int counter = 0;
1723                         foreach (TSource element in source) {
1724                                 foreach (TResult item in selector (element, counter))
1725                                         yield return item;
1726                                 counter++;
1727                         }
1728                 }
1729
1730                 public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
1731                         Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1732                 {
1733                         Check.SourceAndCollectionSelectors (source, collectionSelector, selector);
1734
1735                         return CreateSelectManyIterator (source, collectionSelector, selector);
1736                 }
1737
1738                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TCollection, TResult> (IEnumerable<TSource> source,
1739                         Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1740                 {
1741                         foreach (TSource element in source)
1742                                 foreach (TCollection collection in collectionSelector (element))
1743                                         yield return selector (element, collection);
1744                 }
1745
1746                 public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
1747                         Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1748                 {
1749                         Check.SourceAndCollectionSelectors (source, collectionSelector, selector);
1750
1751                         return CreateSelectManyIterator (source, collectionSelector, selector);
1752                 }
1753
1754                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TCollection, TResult> (IEnumerable<TSource> source,
1755                         Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1756                 {
1757                         int counter = 0;
1758                         foreach (TSource element in source)
1759                                 foreach (TCollection collection in collectionSelector (element, counter++))
1760                                         yield return selector (element, collection);
1761                 }
1762
1763                 #endregion
1764
1765                 #region Single
1766
1767                 public static TSource Single<TSource> (this IEnumerable<TSource> source)
1768                 {
1769                         Check.Source (source);
1770
1771                         bool otherElement = false;
1772                         TSource singleElement = default (TSource);
1773                         foreach (TSource element in source) {
1774                                 if (otherElement) throw new InvalidOperationException ();
1775                                 if (!otherElement) otherElement = true;
1776                                 singleElement = element;
1777                         }
1778
1779                         if (otherElement)
1780                                 return singleElement;
1781                         else
1782                                 throw new InvalidOperationException ();
1783                 }
1784
1785
1786                 public static TSource Single<TSource> (this IEnumerable<TSource> source,
1787                                 Func<TSource, bool> predicate)
1788                 {
1789                         Check.SourceAndPredicate (source, predicate);
1790
1791                         bool otherElement = false;
1792                         TSource singleElement = default (TSource);
1793                         foreach (TSource element in source) {
1794                                 if (predicate (element)) {
1795                                         if (otherElement) throw new InvalidOperationException ();
1796                                         if (!otherElement) otherElement = true;
1797                                         singleElement = element;
1798                                 }
1799                         }
1800
1801                         if (otherElement)
1802                                 return singleElement;
1803                         else
1804                                 throw new InvalidOperationException ();
1805                 }
1806
1807                 #endregion
1808
1809                 #region SingleOrDefault
1810
1811                 public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source)
1812                 {
1813                         Check.Source (source);
1814
1815                         bool otherElement = false;
1816                         TSource singleElement = default (TSource);
1817                         foreach (TSource element in source) {
1818                                 if (otherElement) throw new InvalidOperationException ();
1819                                 if (!otherElement) otherElement = true;
1820                                 singleElement = element;
1821                         }
1822
1823                         return singleElement;
1824                 }
1825
1826
1827                 public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source,
1828                                 Func<TSource, bool> predicate)
1829                 {
1830                         Check.SourceAndPredicate (source, predicate);
1831
1832                         bool otherElement = false;
1833                         TSource singleElement = default (TSource);
1834                         foreach (TSource element in source) {
1835                                 if (predicate (element)) {
1836                                         if (otherElement) throw new InvalidOperationException ();
1837                                         if (!otherElement) otherElement = true;
1838                                         singleElement = element;
1839                                 }
1840                         }
1841
1842                         return singleElement;
1843                 }
1844
1845                 #endregion
1846
1847                 #region Skip
1848
1849                 public static IEnumerable<TSource> Skip<TSource> (this IEnumerable<TSource> source, int count)
1850                 {
1851                         Check.Source (source);
1852
1853                         return CreateSkipIterator (source, count);
1854                 }
1855
1856                 static IEnumerable<TSource> CreateSkipIterator<TSource> (IEnumerable<TSource> source, int count)
1857                 {
1858                         int i = 0;
1859                         foreach (var element in source) {
1860                                 if (i++ < count)
1861                                         continue;
1862
1863                                 yield return element;
1864                         }
1865                 }
1866
1867                 #endregion
1868
1869                 #region SkipWhile
1870
1871                 public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
1872                 {
1873                         Check.SourceAndPredicate (source, predicate);
1874
1875                         return CreateSkipWhileIterator (source, predicate);
1876                 }
1877
1878                 static IEnumerable<TSource> CreateSkipWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
1879                 {
1880                         bool yield = false;
1881
1882                         foreach (TSource element in source) {
1883                                 if (yield)
1884                                         yield return element;
1885                                 else
1886                                         if (!predicate (element)) {
1887                                                 yield return element;
1888                                                 yield = true;
1889                                         }
1890                         }
1891                 }
1892
1893                 public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
1894                 {
1895                         Check.SourceAndPredicate (source, predicate);
1896
1897                         return CreateSkipWhileIterator (source, predicate);
1898                 }
1899
1900                 static IEnumerable<TSource> CreateSkipWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
1901                 {
1902                         int counter = 0;
1903                         bool yield = false;
1904
1905                         foreach (TSource element in source) {
1906                                 if (yield)
1907                                         yield return element;
1908                                 else
1909                                         if (!predicate (element, counter)) {
1910                                                 yield return element;
1911                                                 yield = true;
1912                                         }
1913                                 counter++;
1914                         }
1915                 }
1916
1917                 #endregion
1918
1919                 #region Sum
1920
1921                 public static int Sum (this IEnumerable<int> source)
1922                 {
1923                         return Sum<int, int> (source, (a, b) => a + b);
1924                 }
1925
1926                 public static int? Sum (this IEnumerable<int?> source)
1927                 {
1928                         return SumNullable<int?, int?> (source, (a, b) => a.HasValue ? a + b : a);
1929                 }
1930
1931                 public static int Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
1932                 {
1933                         return Sum<TSource, int> (source, (a, b) => a + selector (b));
1934                 }
1935
1936                 public static int? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
1937                 {
1938                         return SumNullable<TSource, int?> (source, (a, b) => {
1939                                 var value = selector (b);
1940                                 return value.HasValue ? a + value.Value : a;
1941                         });
1942                 }
1943
1944                 public static long Sum (this IEnumerable<long> source)
1945                 {
1946                         return Sum<long, long> (source, (a, b) => a + b);
1947                 }
1948
1949                 public static long? Sum (this IEnumerable<long?> source)
1950                 {
1951                         return SumNullable<long?, long?> (source, (a, b) => a.HasValue ? a + b : a);
1952                 }
1953
1954                 public static long Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
1955                 {
1956                         return Sum<TSource, long> (source, (a, b) => a + selector (b));
1957                 }
1958
1959                 public static long? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
1960                 {
1961                         return SumNullable<TSource, long?> (source, (a, b) => {
1962                                 var value = selector (b);
1963                                 return value.HasValue ? a + value.Value : a;
1964                         });
1965                 }
1966
1967                 public static double Sum (this IEnumerable<double> source)
1968                 {
1969                         return Sum<double, double> (source, (a, b) => a + b);
1970                 }
1971
1972                 public static double? Sum (this IEnumerable<double?> source)
1973                 {
1974                         return SumNullable<double?, double?> (source, (a, b) => a.HasValue ? a + b : a);
1975                 }
1976
1977                 public static double Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
1978                 {
1979                         return Sum<TSource, double> (source, (a, b) => a + selector (b));
1980                 }
1981
1982                 public static double? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
1983                 {
1984                         return SumNullable<TSource, double?> (source, (a, b) => {
1985                                 var value = selector (b);
1986                                 return value.HasValue ? a + value.Value : a;
1987                         });
1988                 }
1989
1990                 public static float Sum (this IEnumerable<float> source)
1991                 {
1992                         return Sum<float, float> (source, (a, b) => a + b);
1993                 }
1994
1995                 public static float? Sum (this IEnumerable<float?> source)
1996                 {
1997                         return SumNullable<float?, float?> (source, (a, b) => a.HasValue ? a + b : a);
1998                 }
1999
2000                 public static float Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
2001                 {
2002                         return Sum<TSource, float> (source, (a, b) => a + selector (b));
2003                 }
2004
2005                 public static float? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
2006                 {
2007                         return SumNullable<TSource, float?> (source, (a, b) => {
2008                                 var value = selector (b);
2009                                 return value.HasValue ? a + value.Value : a;
2010                         });
2011                 }
2012
2013                 public static decimal Sum (this IEnumerable<decimal> source)
2014                 {
2015                         return Sum<decimal, decimal> (source, (a, b) => a + b);
2016                 }
2017
2018                 public static decimal? Sum (this IEnumerable<decimal?> source)
2019                 {
2020                         return SumNullable<decimal?, decimal?> (source, (a, b) => a.HasValue ? a + b : a);
2021                 }
2022
2023                 public static decimal Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
2024                 {
2025                         return Sum<TSource, decimal> (source, (a, b) => a + selector (b));
2026                 }
2027
2028                 public static decimal? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
2029                 {
2030                         return SumNullable<TSource, decimal?> (source, (a, b) => {
2031                                 var value = selector (b);
2032                                 return value.HasValue ? a + value.Value : a;
2033                         });
2034                 }
2035
2036                 static TR Sum<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> func)
2037                 {
2038                         Check.Source (source);
2039
2040                         TR total = default (TR);
2041                         int counter = 0;
2042                         foreach (var element in source) {
2043                                 total = func (total, element);
2044                                 ++counter;
2045                         }
2046
2047                         if (counter == 0)
2048                                 throw new InvalidOperationException ();
2049
2050                         return total;
2051                 }
2052
2053                 static TR SumNullable<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> func)
2054                 {
2055                         Check.Source (source);
2056
2057                         TR total = default (TR);
2058                         foreach (var element in source) {
2059                                 total = func (total, element);
2060                         }
2061
2062                         return total;
2063                 }
2064
2065                 #endregion
2066
2067                 #region Take
2068
2069                 public static IEnumerable<TSource> Take<TSource> (this IEnumerable<TSource> source, int count)
2070                 {
2071                         Check.Source (source);
2072
2073                         return CreateTakeIterator (source, count);
2074                 }
2075
2076                 static IEnumerable<TSource> CreateTakeIterator<TSource> (IEnumerable<TSource> source, int count)
2077                 {
2078                         if (count <= 0)
2079                                 yield break;
2080
2081                         int counter = 0;
2082                         foreach (TSource element in source) {
2083                                 if (counter++ == count)
2084                                         yield break;
2085
2086                                 yield return element;
2087                         }
2088                 }
2089
2090                 #endregion
2091
2092                 #region TakeWhile
2093
2094                 public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
2095                 {
2096                         Check.SourceAndPredicate (source, predicate);
2097
2098                         return CreateTakeWhileIterator (source, predicate);
2099                 }
2100
2101                 static IEnumerable<TSource> CreateTakeWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
2102                 {
2103                         foreach (TSource element in source) {
2104                                 if (!predicate (element))
2105                                         yield break;
2106
2107                                 yield return element;
2108                         }
2109                 }
2110
2111                 public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2112                 {
2113                         Check.SourceAndPredicate (source, predicate);
2114
2115                         return CreateTakeWhileIterator (source, predicate);
2116                 }
2117
2118                 static IEnumerable<TSource> CreateTakeWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2119                 {
2120                         int counter = 0;
2121                         foreach (var element in source) {
2122                                 if (!predicate (element, counter))
2123                                         yield break;
2124
2125                                 yield return element;
2126                                 counter++;
2127                         }
2128                 }
2129
2130                 #endregion
2131
2132                 #region ThenBy
2133
2134                 public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
2135                 {
2136                         return ThenBy<TSource, TKey> (source, keySelector, null);
2137                 }
2138
2139
2140                 public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2141                         Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
2142                 {
2143                         Check.SourceAndKeySelector (source, keySelector);
2144
2145                         return source.CreateOrderedEnumerable (keySelector, comparer, false);
2146                 }
2147
2148                 #endregion
2149
2150                 #region ThenByDescending
2151
2152                 public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2153                         Func<TSource, TKey> keySelector)
2154                 {
2155                         return ThenByDescending<TSource, TKey> (source, keySelector, null);
2156                 }
2157
2158
2159                 public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2160                         Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
2161                 {
2162                         Check.SourceAndKeySelector (source, keySelector);
2163
2164                         return source.CreateOrderedEnumerable (keySelector, comparer, true);
2165                 }
2166
2167                 #endregion
2168
2169                 #region ToArray
2170                 public static TSource [] ToArray<TSource> (this IEnumerable<TSource> source)
2171                 {
2172                         Check.Source (source);
2173
2174                         List<TSource> list = new List<TSource> (source);
2175                         return list.ToArray ();
2176                 }
2177
2178                 #endregion
2179
2180                 #region ToDictionary
2181                 public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2182                                 Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
2183                 {
2184                         return ToDictionary<TSource, TKey, TElement> (source, keySelector, elementSelector, null);
2185                 }
2186
2187                 public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2188                                 Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
2189                 {
2190                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
2191
2192                         var dict = new Dictionary<TKey, TElement> (comparer);
2193                         foreach (var e in source)
2194                                 dict.Add (keySelector (e), elementSelector (e));
2195
2196                         return dict;
2197                 }
2198
2199                 public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source,
2200                                 Func<TSource, TKey> keySelector)
2201                 {
2202                         return ToDictionary (source, keySelector, null);
2203                 }
2204
2205                 public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source,
2206                                 Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
2207                 {
2208                         throw new NotImplementedException ();
2209                         // FIXME: compiler issue
2210                         //return ToDictionary (source, keySelector, (a) => a, comparer);
2211                 }
2212
2213                 #endregion
2214
2215                 #region ToList
2216                 public static List<TSource> ToList<TSource> (this IEnumerable<TSource> source)
2217                 {
2218                         Check.Source (source);
2219
2220                         return new List<TSource> (source);
2221                 }
2222                 #endregion
2223
2224                 #region ToLookup
2225
2226                 public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
2227                 {
2228                         return ToLookup<TSource, TKey> (source, keySelector, null);
2229                 }
2230
2231                 public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source,
2232                         Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
2233                 {
2234                         Check.SourceAndKeySelector (source, keySelector);
2235
2236                         var dictionary = new Dictionary<TKey, List<TSource>> (comparer ?? EqualityComparer<TKey>.Default);
2237                         foreach (TSource element in source) {
2238                                 TKey key = keySelector (element);
2239                                 if (key == null)
2240                                         throw new ArgumentNullException ();
2241                                 if (!dictionary.ContainsKey (key))
2242                                         dictionary.Add (key, new List<TSource> ());
2243                                 dictionary [key].Add (element);
2244                         }
2245                         return new Lookup<TKey, TSource> (dictionary);
2246                 }
2247
2248                 public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2249                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
2250                 {
2251                         return ToLookup<TSource, TKey, TElement> (source, keySelector, elementSelector, null);
2252                 }
2253
2254                 public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2255                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
2256                 {
2257                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
2258
2259                         Dictionary<TKey, List<TElement>> dictionary = new Dictionary<TKey, List<TElement>> (comparer ?? EqualityComparer<TKey>.Default);
2260                         foreach (TSource element in source) {
2261                                 TKey key = keySelector (element);
2262                                 if (key == null)
2263                                         throw new ArgumentNullException ();
2264                                 if (!dictionary.ContainsKey (key))
2265                                         dictionary.Add (key, new List<TElement> ());
2266                                 dictionary [key].Add (elementSelector (element));
2267                         }
2268                         return new Lookup<TKey, TElement> (dictionary);
2269                 }
2270
2271                 #endregion
2272
2273                 #region SequenceEqual
2274
2275                 public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
2276                 {
2277                         return first.SequenceEqual (second, null);
2278                 }
2279
2280                 public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2281                 {
2282                         Check.FirstAndSecond (first, second);
2283
2284                         if (comparer == null)
2285                                 comparer = EqualityComparer<TSource>.Default;
2286
2287                         var first_enumerator = first.GetEnumerator ();
2288                         var second_enumerator = second.GetEnumerator ();
2289
2290                         while (first_enumerator.MoveNext ()) {
2291                                 if (!second_enumerator.MoveNext ())
2292                                         return false;
2293
2294                                 if (!comparer.Equals (first_enumerator.Current, second_enumerator.Current))
2295                                         return false;
2296                         }
2297
2298                         return !second_enumerator.MoveNext ();
2299                 }
2300
2301                 #endregion
2302
2303                 #region Union
2304
2305                 public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
2306                 {
2307                         Check.FirstAndSecond (first, second);
2308
2309                         return first.Union (second, null);
2310                 }
2311
2312                 public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2313                 {
2314                         Check.FirstAndSecond (first, second);
2315
2316                         if (comparer == null)
2317                                 comparer = EqualityComparer<TSource>.Default;
2318
2319                         return CreateUnionIterator (first, second, comparer);
2320                 }
2321
2322                 static IEnumerable<TSource> CreateUnionIterator<TSource> (IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2323                 {
2324                         var items = new HashSet<TSource> (comparer);
2325                         foreach (var element in first) {
2326                                 if (! items.Contains (element)) {
2327                                         items.Add (element);
2328                                         yield return element;
2329                                 }
2330                         }
2331
2332                         foreach (var element in second) {
2333                                 if (! items.Contains (element, comparer)) {
2334                                         items.Add (element);
2335                                         yield return element;
2336                                 }
2337                         }
2338                 }
2339
2340                 #endregion
2341
2342                 #region Where
2343
2344                 public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
2345                 {
2346                         Check.SourceAndPredicate (source, predicate);
2347
2348                         return CreateWhereIterator (source, predicate);
2349                 }
2350
2351                 static IEnumerable<TSource> CreateWhereIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
2352                 {
2353                         foreach (TSource element in source)
2354                                 if (predicate (element))
2355                                         yield return element;
2356                 }
2357
2358                 public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2359                 {
2360                         Check.SourceAndPredicate (source, predicate);
2361
2362                         return CreateWhereIterator (source, predicate);
2363                 }
2364
2365                 static IEnumerable<TSource> CreateWhereIterator<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2366                 {
2367                         int counter = 0;
2368                         foreach (TSource element in source) {
2369                                 if (predicate (element, counter))
2370                                         yield return element;
2371                                 counter++;
2372                         }
2373                 }
2374
2375                 #endregion
2376
2377                 internal static ReadOnlyCollection<TSource> ToReadOnlyCollection<TSource> (this IEnumerable<TSource> source)
2378                 {
2379                         if (source == null)
2380                                 return new ReadOnlyCollection<TSource> (new TSource [0]); // could we singlotenize that?
2381
2382                         var ro = source as ReadOnlyCollection<TSource>;
2383                         if (ro != null)
2384                                 return ro;
2385
2386                         return new ReadOnlyCollection<TSource> (source.ToArray<TSource> ());
2387                 }
2388         }
2389 }