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) => (double) a / (double) b);
 141                 }
 142
 143                 public static double Average (this IEnumerable<long> source)
 144                 {
 145                         return Average (source, (a, b) => a + b, (a, b) => (double) a / (double) 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                         Check.Source (source);
1096
1097                         return Iterate (source, int.MinValue, (a, b) => Math.Max (a, b));
1098                 }
1099
1100                 public static long Max (this IEnumerable<long> source)
1101                 {
1102                         Check.Source (source);
1103
1104                         return Iterate (source, long.MinValue, (a, b) => Math.Max (a, b));
1105                 }
1106
1107                 public static double Max (this IEnumerable<double> source)
1108                 {
1109                         Check.Source (source);
1110
1111                         return Iterate (source, double.MinValue, (a, b) => Math.Max (a, b));
1112                 }
1113
1114                 public static float Max (this IEnumerable<float> source)
1115                 {
1116                         Check.Source (source);
1117
1118                         return Iterate (source, float.MinValue, (a, b) => Math.Max (a, b));
1119                 }
1120
1121                 public static decimal Max (this IEnumerable<decimal> source)
1122                 {
1123                         Check.Source (source);
1124
1125                         return Iterate (source, decimal.MinValue, (a, b) => Math.Max (a, b));
1126                 }
1127
1128                 public static int? Max (this IEnumerable<int?> source)
1129                 {
1130                         Check.Source (source);
1131
1132                         return IterateNullable (source, int.MinValue, (a, b) => a > b);
1133                 }
1134
1135                 public static long? Max (this IEnumerable<long?> source)
1136                 {
1137                         Check.Source (source);
1138
1139                         return IterateNullable (source, long.MinValue, (a, b) => a > b);
1140                 }
1141
1142                 public static double? Max (this IEnumerable<double?> source)
1143                 {
1144                         Check.Source (source);
1145
1146                         return IterateNullable (source, double.MinValue, (a, b) => a > b);
1147                 }
1148
1149                 public static float? Max (this IEnumerable<float?> source)
1150                 {
1151                         Check.Source (source);
1152
1153                         return IterateNullable (source, float.MinValue, (a, b) => a > b);
1154                 }
1155
1156                 public static decimal? Max (this IEnumerable<decimal?> source)
1157                 {
1158                         Check.Source (source);
1159
1160                         return IterateNullable (source, decimal.MinValue, (a, b) => a > b);
1161                 }
1162
1163                 static T? IterateNullable<T> (IEnumerable<T?> source, T initValue, Func<T?, T?, bool> selector) where T : struct
1164                 {
1165                         int counter = 0;
1166                         T? value = initValue;
1167                         foreach (var element in source) {
1168                                 if (!element.HasValue)
1169                                         continue;
1170
1171                                 if (selector (element.Value, value))
1172                                         value = element;
1173                                 ++counter;
1174                         }
1175
1176                         if (counter == 0)
1177                                 return null;
1178
1179                         return value;
1180                 }
1181
1182                 public static TSource Max<TSource> (this IEnumerable<TSource> source)
1183                 {
1184                         Check.Source (source);
1185
1186                         bool notAssigned = true;
1187                         TSource maximum = default (TSource);
1188                         int counter = 0;
1189                         foreach (TSource element in source) {
1190                                 if (notAssigned) {
1191                                         maximum = element;
1192                                         notAssigned = false;
1193                                 } else {
1194                                         int comparison;
1195                                         if (element is IComparable<TSource>)
1196                                                 comparison = ((IComparable<TSource>) element).CompareTo (maximum);
1197                                         else if (element is System.IComparable)
1198                                                 comparison = ((System.IComparable) element).CompareTo (maximum);
1199                                         else
1200                                                 throw new ArgumentNullException ();
1201
1202                                         if (comparison > 0)
1203                                                 maximum = element;
1204                                 }
1205                                 counter++;
1206                         }
1207
1208                         if (counter == 0)
1209                                 throw new InvalidOperationException ();
1210                         else
1211                                 return maximum;
1212                 }
1213
1214                 public static int Max<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
1215                 {
1216                         Check.SourceAndSelector (source, selector);
1217
1218                         return Iterate (source, int.MinValue, (a, b) => Math.Max (selector (a), b));
1219                 }
1220
1221                 public static long Max<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
1222                 {
1223                         Check.SourceAndSelector (source, selector);
1224
1225                         return Iterate (source, long.MinValue, (a, b) => Math.Max (selector (a), b));
1226                 }
1227
1228                 public static double Max<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
1229                 {
1230                         Check.SourceAndSelector (source, selector);
1231
1232                         return Iterate (source, double.MinValue, (a, b) => Math.Max (selector (a), b));
1233                 }
1234
1235                 public static float Max<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
1236                 {
1237                         Check.SourceAndSelector (source, selector);
1238
1239                         return Iterate (source, float.MinValue, (a, b) => Math.Max (selector (a), b));
1240                 }
1241
1242                 public static decimal Max<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
1243                 {
1244                         Check.SourceAndSelector (source, selector);
1245
1246                         return Iterate (source, decimal.MinValue, (a, b) => Math.Max (selector (a), b));
1247                 }
1248
1249                 static U Iterate<T, U> (IEnumerable<T> source, U initValue, Func<T, U, U> selector)
1250                 {
1251                         int counter = 0;
1252                         foreach (var element in source) {
1253                                 initValue = selector (element, initValue);
1254                                 ++counter;
1255                         }
1256
1257                         if (counter == 0)
1258                                 throw new InvalidOperationException ();
1259
1260                         return initValue;
1261                 }
1262
1263                 static U? IterateNullable<T, U> (IEnumerable<T> source, U initialValue, Func<T, U?, U?> selector) where U : struct
1264                 {
1265                         int counter = 0;
1266                         U? value = initialValue;
1267                         foreach (var element in source) {
1268                                 value = selector (element, value);
1269                                 if (!value.HasValue)
1270                                         continue;
1271
1272                                 ++counter;
1273                         }
1274
1275                         if (counter == 0)
1276                                 return null;
1277
1278                         return value;
1279                 }
1280
1281                 public static int? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
1282                 {
1283                         Check.SourceAndSelector (source, selector);
1284
1285                         return IterateNullable (source, int.MinValue, (a, b) => {
1286                                 var v = selector (a); return v > b ? v : b;
1287                         });
1288                 }
1289
1290                 public static long? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
1291                 {
1292                         Check.SourceAndSelector (source, selector);
1293
1294                         return IterateNullable (source, long.MinValue, (a, b) => {
1295                                 var v = selector (a); return v > b ? v : b;
1296                         });
1297                 }
1298
1299                 public static double? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
1300                 {
1301                         Check.SourceAndSelector (source, selector);
1302
1303                         return IterateNullable (source, double.MinValue, (a, b) => {
1304                                 var v = selector (a); return v > b ? v : b;
1305                         });
1306                 }
1307
1308                 public static float? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
1309                 {
1310                         Check.SourceAndSelector (source, selector);
1311
1312                         return IterateNullable (source, float.MinValue, (a, b) => {
1313                                 var v = selector (a); return v > b ? v : b;
1314                         });
1315                 }
1316
1317                 public static decimal? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
1318                 {
1319                         Check.SourceAndSelector (source, selector);
1320
1321                         return IterateNullable (source, decimal.MinValue, (a, b) => {
1322                                 var v = selector (a); return v > b ? v : b;
1323                         });
1324                 }
1325
1326                 public static TResult Max<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
1327                 {
1328                         Check.SourceAndSelector (source, selector);
1329
1330                         bool notAssigned = true;
1331                         TResult maximum = default (TResult);
1332                         int counter = 0;
1333                         foreach (TSource item in source) {
1334                                 TResult element = selector (item);
1335                                 if (notAssigned) {
1336                                         maximum = element;
1337                                         notAssigned = false;
1338                                 } else {
1339                                         int comparison;
1340                                         if (element is IComparable<TResult>)
1341                                                 comparison = ((IComparable<TResult>) element).CompareTo (maximum);
1342                                         else if (element is System.IComparable)
1343                                                 comparison = ((System.IComparable) element).CompareTo (maximum);
1344                                         else
1345                                                 throw new ArgumentNullException ();
1346
1347                                         if (comparison > 0)
1348                                                 maximum = element;
1349                                 }
1350                                 counter++;
1351                         }
1352
1353                         if (counter == 0)
1354                                 throw new InvalidOperationException ();
1355                         else
1356                                 return maximum;
1357                 }
1358
1359                 #endregion
1360
1361                 #region Min
1362
1363                 public static int Min (this IEnumerable<int> source)
1364                 {
1365                         Check.Source (source);
1366
1367                         return Iterate (source, int.MaxValue, (a, b) => Math.Min (a, b));
1368                 }
1369
1370                 public static long Min (this IEnumerable<long> source)
1371                 {
1372                         Check.Source (source);
1373
1374                         return Iterate (source, long.MaxValue, (a, b) => Math.Min (a, b));
1375                 }
1376
1377                 public static double Min (this IEnumerable<double> source)
1378                 {
1379                         Check.Source (source);
1380
1381                         return Iterate (source, double.MaxValue, (a, b) => Math.Min (a, b));
1382                 }
1383
1384                 public static float Min (this IEnumerable<float> source)
1385                 {
1386                         Check.Source (source);
1387
1388                         return Iterate (source, float.MaxValue, (a, b) => Math.Min (a, b));
1389                 }
1390
1391                 public static decimal Min (this IEnumerable<decimal> source)
1392                 {
1393                         Check.Source (source);
1394
1395                         return Iterate (source, decimal.MaxValue, (a, b) => Math.Min (a, b));
1396                 }
1397
1398                 public static int? Min (this IEnumerable<int?> source)
1399                 {
1400                         Check.Source (source);
1401
1402                         return IterateNullable (source, int.MaxValue, (a, b) => a < b);
1403                 }
1404
1405                 public static long? Min (this IEnumerable<long?> source)
1406                 {
1407                         Check.Source (source);
1408
1409                         return IterateNullable (source, long.MaxValue, (a, b) => a < b);
1410                 }
1411
1412                 public static double? Min (this IEnumerable<double?> source)
1413                 {
1414                         Check.Source (source);
1415
1416                         return IterateNullable (source, double.MaxValue, (a, b) => a < b);
1417                 }
1418
1419                 public static float? Min (this IEnumerable<float?> source)
1420                 {
1421                         Check.Source (source);
1422
1423                         return IterateNullable (source, float.MaxValue, (a, b) => a < b);
1424                 }
1425
1426                 public static decimal? Min (this IEnumerable<decimal?> source)
1427                 {
1428                         Check.Source (source);
1429
1430                         return IterateNullable (source, decimal.MaxValue, (a, b) => a < b);
1431                 }
1432
1433                 public static TSource Min<TSource> (this IEnumerable<TSource> source)
1434                 {
1435                         Check.Source (source);
1436
1437                         bool notAssigned = true;
1438                         TSource minimum = default (TSource);
1439                         int counter = 0;
1440                         foreach (TSource element in source) {
1441                                 if (notAssigned) {
1442                                         minimum = element;
1443                                         notAssigned = false;
1444                                 } else {
1445                                         int comparison;
1446                                         if (element is IComparable<TSource>)
1447                                                 comparison = ((IComparable<TSource>) element).CompareTo (minimum);
1448                                         else if (element is System.IComparable)
1449                                                 comparison = ((System.IComparable) element).CompareTo (minimum);
1450                                         else
1451                                                 throw new ArgumentNullException ();
1452
1453                                         if (comparison < 0)
1454                                                 minimum = element;
1455                                 }
1456                                 counter++;
1457                         }
1458
1459                         if (counter == 0)
1460                                 throw new InvalidOperationException ();
1461                         else
1462                                 return minimum;
1463                 }
1464
1465                 public static int Min<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
1466                 {
1467                         Check.SourceAndSelector (source, selector);
1468
1469                         return Iterate (source, int.MaxValue, (a, b) => Math.Min (selector (a), b));
1470                 }
1471
1472                 public static long Min<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
1473                 {
1474                         Check.SourceAndSelector (source, selector);
1475
1476                         return Iterate (source, long.MaxValue, (a, b) => Math.Min (selector (a), b));
1477                 }
1478
1479                 public static double Min<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
1480                 {
1481                         Check.SourceAndSelector (source, selector);
1482
1483                         return Iterate (source, double.MaxValue, (a, b) => Math.Min (selector (a), b));
1484                 }
1485
1486                 public static float Min<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
1487                 {
1488                         Check.SourceAndSelector (source, selector);
1489
1490                         return Iterate (source, float.MaxValue, (a, b) => Math.Min (selector (a), b));
1491                 }
1492
1493                 public static decimal Min<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
1494                 {
1495                         Check.SourceAndSelector (source, selector);
1496
1497                         return Iterate (source, decimal.MaxValue, (a, b) => Math.Min (selector (a), b));
1498                 }
1499
1500                 public static int? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
1501                 {
1502                         Check.SourceAndSelector (source, selector);
1503
1504                         return IterateNullable (source, int.MaxValue, (a, b) => {
1505                                 var v = selector (a); return v < b ? v : b;
1506                         });
1507                 }
1508
1509                 public static long? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
1510                 {
1511                         Check.SourceAndSelector (source, selector);
1512
1513                         return IterateNullable (source, long.MaxValue, (a, b) => {
1514                                 var v = selector (a); return v < b ? v : b;
1515                         });
1516                 }
1517
1518                 public static float? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
1519                 {
1520                         Check.SourceAndSelector (source, selector);
1521
1522                         return IterateNullable (source, float.MaxValue, (a, b) => {
1523                                 var v = selector (a); return v < b ? v : b;
1524                         });
1525                 }
1526
1527                 public static double? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
1528                 {
1529                         Check.SourceAndSelector (source, selector);
1530
1531                         return IterateNullable (source, double.MaxValue, (a, b) => {
1532                                 var v = selector (a); return v < b ? v : b;
1533                         });
1534                 }
1535
1536                 public static decimal? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
1537                 {
1538                         Check.SourceAndSelector (source, selector);
1539
1540                         return IterateNullable (source, decimal.MaxValue, (a, b) => {
1541                                 var v = selector (a); return v < b ? v : b;
1542                         });
1543                 }
1544
1545                 public static TResult Min<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
1546                 {
1547                         Check.SourceAndSelector (source, selector);
1548
1549                         bool notAssigned = true;
1550                         TResult minimum = default (TResult);
1551                         int counter = 0;
1552                         foreach (TSource item in source) {
1553                                 TResult element = selector (item);
1554                                 if (notAssigned) {
1555                                         minimum = element;
1556                                         notAssigned = false;
1557                                 } else {
1558                                         int comparison;
1559                                         if (element is IComparable<TResult>)
1560                                                 comparison = ((IComparable<TResult>) element).CompareTo (minimum);
1561                                         else if (element is System.IComparable)
1562                                                 comparison = ((System.IComparable) element).CompareTo (minimum);
1563                                         else
1564                                                 throw new ArgumentNullException ();
1565
1566                                         if (comparison < 0)
1567                                                 minimum = element;
1568                                 }
1569                                 counter++;
1570                         }
1571
1572                         if (counter == 0)
1573                                 throw new InvalidOperationException ();
1574                         else
1575                                 return minimum;
1576                 }
1577
1578                 #endregion
1579
1580                 #region OfType
1581
1582                 public static IEnumerable<TResult> OfType<TResult> (this IEnumerable source)
1583                 {
1584                         Check.Source (source);
1585
1586                         return CreateOfTypeIterator<TResult> (source);
1587                 }
1588
1589                 static IEnumerable<TResult> CreateOfTypeIterator<TResult> (IEnumerable source)
1590                 {
1591                         foreach (object element in source)
1592                                 if (element is TResult)
1593                                         yield return (TResult) element;
1594                 }
1595
1596                 #endregion
1597
1598                 #region OrderBy
1599
1600                 public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source,
1601                                 Func<TSource, TKey> keySelector)
1602                 {
1603                         return OrderBy<TSource, TKey> (source, keySelector, null);
1604                 }
1605
1606                 public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source,
1607                                 Func<TSource, TKey> keySelector,
1608                                 IComparer<TKey> comparer)
1609                 {
1610                         Check.SourceAndKeySelector (source, keySelector);
1611
1612                         return new OrderedSequence<TSource, TKey> (
1613                                         source, keySelector, comparer, SortDirection.Ascending);
1614                 }
1615
1616                 #endregion
1617
1618                 #region OrderByDescending
1619
1620                 public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source,
1621                                 Func<TSource, TKey> keySelector)
1622                 {
1623                         return OrderByDescending<TSource, TKey> (source, keySelector, null);
1624                 }
1625
1626                 public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source,
1627                                 Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
1628                 {
1629                         Check.SourceAndKeySelector (source, keySelector);
1630
1631                         return new OrderedSequence<TSource, TKey> (
1632                                         source, keySelector, comparer, SortDirection.Descending);
1633                 }
1634
1635                 #endregion
1636
1637                 #region Range
1638
1639                 public static IEnumerable<int> Range (int start, int count)
1640                 {
1641                         if (count < 0)
1642                                 throw new ArgumentOutOfRangeException ("count");
1643
1644                         long upto = ((long) start + count) - 1;
1645
1646                         if (upto > int.MaxValue)
1647                                 throw new ArgumentOutOfRangeException ();
1648
1649                         return CreateRangeIterator (start, (int) upto);
1650                 }
1651
1652                 static IEnumerable<int> CreateRangeIterator (int start, int upto)
1653                 {
1654                         for (int i = start; i <= upto; i++)
1655                                 yield return i;
1656                 }
1657
1658                 #endregion
1659
1660                 #region Repeat
1661
1662                 public static IEnumerable<TResult> Repeat<TResult> (TResult element, int count)
1663                 {
1664                         if (count < 0)
1665                                 throw new ArgumentOutOfRangeException ();
1666
1667                         return CreateRepeatIterator (element, count);
1668                 }
1669
1670                 static IEnumerable<TResult> CreateRepeatIterator<TResult> (TResult element, int count)
1671                 {
1672                         for (int i = 0; i < count; i++)
1673                                 yield return element;
1674                 }
1675
1676                 #endregion
1677
1678
1679                 #region Reverse
1680
1681                 public static IEnumerable<TSource> Reverse<TSource> (this IEnumerable<TSource> source)
1682                 {
1683                         Check.Source (source);
1684
1685                         return CreateReverseIterator (source);
1686                 }
1687
1688                 static IEnumerable<TSource> CreateReverseIterator<TSource> (IEnumerable<TSource> source)
1689                 {
1690                         var list = new List<TSource> (source);
1691                         list.Reverse ();
1692                         return list;
1693                 }
1694
1695                 #endregion
1696
1697                 #region Select
1698
1699                 public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
1700                 {
1701                         Check.SourceAndSelector (source, selector);
1702
1703                         return CreateSelectIterator (source, selector);
1704                 }
1705
1706                 static IEnumerable<TResult> CreateSelectIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, TResult> selector)
1707                 {
1708                         foreach (TSource element in source)
1709                                 yield return selector (element);
1710                 }
1711
1712                 public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
1713                 {
1714                         Check.SourceAndSelector (source, selector);
1715
1716                         return CreateSelectIterator (source, selector);
1717                 }
1718
1719                 static IEnumerable<TResult> CreateSelectIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
1720                 {
1721                         int counter = 0;
1722                         foreach (TSource element in source) {
1723                                 yield return selector (element, counter);
1724                                 counter++;
1725                         }
1726                 }
1727
1728                 #endregion
1729
1730                 #region SelectMany
1731
1732                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
1733                 {
1734                         Check.SourceAndSelector (source, selector);
1735
1736                         return CreateSelectManyIterator (source, selector);
1737                 }
1738
1739                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
1740                 {
1741                         foreach (TSource element in source)
1742                                 foreach (TResult item in selector (element))
1743                                         yield return item;
1744                 }
1745
1746                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
1747                 {
1748                         Check.SourceAndSelector (source, selector);
1749
1750                         return CreateSelectManyIterator (source, selector);
1751                 }
1752
1753                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
1754                 {
1755                         int counter = 0;
1756                         foreach (TSource element in source) {
1757                                 foreach (TResult item in selector (element, counter))
1758                                         yield return item;
1759                                 counter++;
1760                         }
1761                 }
1762
1763                 public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
1764                         Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1765                 {
1766                         Check.SourceAndCollectionSelectors (source, collectionSelector, selector);
1767
1768                         return CreateSelectManyIterator (source, collectionSelector, selector);
1769                 }
1770
1771                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TCollection, TResult> (IEnumerable<TSource> source,
1772                         Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1773                 {
1774                         foreach (TSource element in source)
1775                                 foreach (TCollection collection in collectionSelector (element))
1776                                         yield return selector (element, collection);
1777                 }
1778
1779                 public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
1780                         Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1781                 {
1782                         Check.SourceAndCollectionSelectors (source, collectionSelector, selector);
1783
1784                         return CreateSelectManyIterator (source, collectionSelector, selector);
1785                 }
1786
1787                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TCollection, TResult> (IEnumerable<TSource> source,
1788                         Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1789                 {
1790                         int counter = 0;
1791                         foreach (TSource element in source)
1792                                 foreach (TCollection collection in collectionSelector (element, counter++))
1793                                         yield return selector (element, collection);
1794                 }
1795
1796                 #endregion
1797
1798                 #region Single
1799
1800                 public static TSource Single<TSource> (this IEnumerable<TSource> source)
1801                 {
1802                         Check.Source (source);
1803
1804                         bool otherElement = false;
1805                         TSource singleElement = default (TSource);
1806                         foreach (TSource element in source) {
1807                                 if (otherElement) throw new InvalidOperationException ();
1808                                 if (!otherElement) otherElement = true;
1809                                 singleElement = element;
1810                         }
1811
1812                         if (otherElement)
1813                                 return singleElement;
1814                         else
1815                                 throw new InvalidOperationException ();
1816                 }
1817
1818
1819                 public static TSource Single<TSource> (this IEnumerable<TSource> source,
1820                                 Func<TSource, bool> predicate)
1821                 {
1822                         Check.SourceAndPredicate (source, predicate);
1823
1824                         bool otherElement = false;
1825                         TSource singleElement = default (TSource);
1826                         foreach (TSource element in source) {
1827                                 if (predicate (element)) {
1828                                         if (otherElement) throw new InvalidOperationException ();
1829                                         if (!otherElement) otherElement = true;
1830                                         singleElement = element;
1831                                 }
1832                         }
1833
1834                         if (otherElement)
1835                                 return singleElement;
1836                         else
1837                                 throw new InvalidOperationException ();
1838                 }
1839
1840                 #endregion
1841
1842                 #region SingleOrDefault
1843
1844                 public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source)
1845                 {
1846                         Check.Source (source);
1847
1848                         bool otherElement = false;
1849                         TSource singleElement = default (TSource);
1850                         foreach (TSource element in source) {
1851                                 if (otherElement) throw new InvalidOperationException ();
1852                                 if (!otherElement) otherElement = true;
1853                                 singleElement = element;
1854                         }
1855
1856                         return singleElement;
1857                 }
1858
1859
1860                 public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source,
1861                                 Func<TSource, bool> predicate)
1862                 {
1863                         Check.SourceAndPredicate (source, predicate);
1864
1865                         bool otherElement = false;
1866                         TSource singleElement = default (TSource);
1867                         foreach (TSource element in source) {
1868                                 if (predicate (element)) {
1869                                         if (otherElement) throw new InvalidOperationException ();
1870                                         if (!otherElement) otherElement = true;
1871                                         singleElement = element;
1872                                 }
1873                         }
1874
1875                         return singleElement;
1876                 }
1877
1878                 #endregion
1879
1880                 #region Skip
1881
1882                 public static IEnumerable<TSource> Skip<TSource> (this IEnumerable<TSource> source, int count)
1883                 {
1884                         Check.Source (source);
1885
1886                         return CreateSkipIterator (source, count);
1887                 }
1888
1889                 static IEnumerable<TSource> CreateSkipIterator<TSource> (IEnumerable<TSource> source, int count)
1890                 {
1891                         int i = 0;
1892                         foreach (var element in source) {
1893                                 if (i++ < count)
1894                                         continue;
1895
1896                                 yield return element;
1897                         }
1898                 }
1899
1900                 #endregion
1901
1902                 #region SkipWhile
1903
1904                 public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
1905                 {
1906                         Check.SourceAndPredicate (source, predicate);
1907
1908                         return CreateSkipWhileIterator (source, predicate);
1909                 }
1910
1911                 static IEnumerable<TSource> CreateSkipWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
1912                 {
1913                         bool yield = false;
1914
1915                         foreach (TSource element in source) {
1916                                 if (yield)
1917                                         yield return element;
1918                                 else
1919                                         if (!predicate (element)) {
1920                                                 yield return element;
1921                                                 yield = true;
1922                                         }
1923                         }
1924                 }
1925
1926                 public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
1927                 {
1928                         Check.SourceAndPredicate (source, predicate);
1929
1930                         return CreateSkipWhileIterator (source, predicate);
1931                 }
1932
1933                 static IEnumerable<TSource> CreateSkipWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
1934                 {
1935                         int counter = 0;
1936                         bool yield = false;
1937
1938                         foreach (TSource element in source) {
1939                                 if (yield)
1940                                         yield return element;
1941                                 else
1942                                         if (!predicate (element, counter)) {
1943                                                 yield return element;
1944                                                 yield = true;
1945                                         }
1946                                 counter++;
1947                         }
1948                 }
1949
1950                 #endregion
1951
1952                 #region Sum
1953
1954                 public static int Sum (this IEnumerable<int> source)
1955                 {
1956                         Check.Source (source);
1957
1958                         return Sum<int, int> (source, (a, b) => a + b);
1959                 }
1960
1961                 public static int? Sum (this IEnumerable<int?> source)
1962                 {
1963                         Check.Source (source);
1964
1965                         return SumNullable<int?, int?> (source, (a, b) => a.HasValue ? a + b : a);
1966                 }
1967
1968                 public static int Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
1969                 {
1970                         Check.SourceAndSelector (source, selector);
1971
1972                         return Sum<TSource, int> (source, (a, b) => a + selector (b));
1973                 }
1974
1975                 public static int? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
1976                 {
1977                         Check.SourceAndSelector (source, selector);
1978
1979                         return SumNullable<TSource, int?> (source, (a, b) => {
1980                                 var value = selector (b);
1981                                 return value.HasValue ? a + value.Value : a;
1982                         });
1983                 }
1984
1985                 public static long Sum (this IEnumerable<long> source)
1986                 {
1987                         Check.Source (source);
1988
1989                         return Sum<long, long> (source, (a, b) => a + b);
1990                 }
1991
1992                 public static long? Sum (this IEnumerable<long?> source)
1993                 {
1994                         Check.Source (source);
1995
1996                         return SumNullable<long?, long?> (source, (a, b) => a.HasValue ? a + b : a);
1997                 }
1998
1999                 public static long Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
2000                 {
2001                         Check.SourceAndSelector (source, selector);
2002
2003                         return Sum<TSource, long> (source, (a, b) => a + selector (b));
2004                 }
2005
2006                 public static long? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
2007                 {
2008                         Check.SourceAndSelector (source, selector);
2009
2010                         return SumNullable<TSource, long?> (source, (a, b) => {
2011                                 var value = selector (b);
2012                                 return value.HasValue ? a + value.Value : a;
2013                         });
2014                 }
2015
2016                 public static double Sum (this IEnumerable<double> source)
2017                 {
2018                         Check.Source (source);
2019
2020                         return Sum<double, double> (source, (a, b) => a + b);
2021                 }
2022
2023                 public static double? Sum (this IEnumerable<double?> source)
2024                 {
2025                         Check.Source (source);
2026
2027                         return SumNullable<double?, double?> (source, (a, b) => a.HasValue ? a + b : a);
2028                 }
2029
2030                 public static double Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
2031                 {
2032                         Check.SourceAndSelector (source, selector);
2033
2034                         return Sum<TSource, double> (source, (a, b) => a + selector (b));
2035                 }
2036
2037                 public static double? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
2038                 {
2039                         Check.SourceAndSelector (source, selector);
2040
2041                         return SumNullable<TSource, double?> (source, (a, b) => {
2042                                 var value = selector (b);
2043                                 return value.HasValue ? a + value.Value : a;
2044                         });
2045                 }
2046
2047                 public static float Sum (this IEnumerable<float> source)
2048                 {
2049                         Check.Source (source);
2050
2051                         return Sum<float, float> (source, (a, b) => a + b);
2052                 }
2053
2054                 public static float? Sum (this IEnumerable<float?> source)
2055                 {
2056                         Check.Source (source);
2057
2058                         return SumNullable<float?, float?> (source, (a, b) => a.HasValue ? a + b : a);
2059                 }
2060
2061                 public static float Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
2062                 {
2063                         Check.SourceAndSelector (source, selector);
2064
2065                         return Sum<TSource, float> (source, (a, b) => a + selector (b));
2066                 }
2067
2068                 public static float? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
2069                 {
2070                         Check.SourceAndSelector (source, selector);
2071
2072                         return SumNullable<TSource, float?> (source, (a, b) => {
2073                                 var value = selector (b);
2074                                 return value.HasValue ? a + value.Value : a;
2075                         });
2076                 }
2077
2078                 public static decimal Sum (this IEnumerable<decimal> source)
2079                 {
2080                         Check.Source (source);
2081
2082                         return Sum<decimal, decimal> (source, (a, b) => a + b);
2083                 }
2084
2085                 public static decimal? Sum (this IEnumerable<decimal?> source)
2086                 {
2087                         Check.Source (source);
2088
2089                         return SumNullable<decimal?, decimal?> (source, (a, b) => a.HasValue ? a + b : a);
2090                 }
2091
2092                 public static decimal Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
2093                 {
2094                         Check.SourceAndSelector (source, selector);
2095
2096                         return Sum<TSource, decimal> (source, (a, b) => a + selector (b));
2097                 }
2098
2099                 public static decimal? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
2100                 {
2101                         Check.SourceAndSelector (source, selector);
2102
2103                         return SumNullable<TSource, decimal?> (source, (a, b) => {
2104                                 var value = selector (b);
2105                                 return value.HasValue ? a + value.Value : a;
2106                         });
2107                 }
2108
2109                 static TR Sum<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
2110                 {
2111                         TR total = default (TR);
2112                         int counter = 0;
2113                         foreach (var element in source) {
2114                                 total = selector (total, element);
2115                                 ++counter;
2116                         }
2117
2118                         if (counter == 0)
2119                                 throw new InvalidOperationException ();
2120
2121                         return total;
2122                 }
2123
2124                 static TR SumNullable<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
2125                 {
2126                         TR total = default (TR);
2127                         foreach (var element in source) {
2128                                 total = selector (total, element);
2129                         }
2130
2131                         return total;
2132                 }
2133
2134                 #endregion
2135
2136                 #region Take
2137
2138                 public static IEnumerable<TSource> Take<TSource> (this IEnumerable<TSource> source, int count)
2139                 {
2140                         Check.Source (source);
2141
2142                         return CreateTakeIterator (source, count);
2143                 }
2144
2145                 static IEnumerable<TSource> CreateTakeIterator<TSource> (IEnumerable<TSource> source, int count)
2146                 {
2147                         if (count <= 0)
2148                                 yield break;
2149
2150                         int counter = 0;
2151                         foreach (TSource element in source) {
2152                                 if (counter++ == count)
2153                                         yield break;
2154
2155                                 yield return element;
2156                         }
2157                 }
2158
2159                 #endregion
2160
2161                 #region TakeWhile
2162
2163                 public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
2164                 {
2165                         Check.SourceAndPredicate (source, predicate);
2166
2167                         return CreateTakeWhileIterator (source, predicate);
2168                 }
2169
2170                 static IEnumerable<TSource> CreateTakeWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
2171                 {
2172                         foreach (TSource element in source) {
2173                                 if (!predicate (element))
2174                                         yield break;
2175
2176                                 yield return element;
2177                         }
2178                 }
2179
2180                 public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2181                 {
2182                         Check.SourceAndPredicate (source, predicate);
2183
2184                         return CreateTakeWhileIterator (source, predicate);
2185                 }
2186
2187                 static IEnumerable<TSource> CreateTakeWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2188                 {
2189                         int counter = 0;
2190                         foreach (var element in source) {
2191                                 if (!predicate (element, counter))
2192                                         yield break;
2193
2194                                 yield return element;
2195                                 counter++;
2196                         }
2197                 }
2198
2199                 #endregion
2200
2201                 #region ThenBy
2202
2203                 public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
2204                 {
2205                         return ThenBy<TSource, TKey> (source, keySelector, null);
2206                 }
2207
2208                 public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2209                         Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
2210                 {
2211                         Check.SourceAndKeySelector (source, keySelector);
2212
2213                         return source.CreateOrderedEnumerable (keySelector, comparer, false);
2214                 }
2215
2216                 #endregion
2217
2218                 #region ThenByDescending
2219
2220                 public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2221                         Func<TSource, TKey> keySelector)
2222                 {
2223                         return ThenByDescending<TSource, TKey> (source, keySelector, null);
2224                 }
2225
2226                 public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2227                         Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
2228                 {
2229                         Check.SourceAndKeySelector (source, keySelector);
2230
2231                         return source.CreateOrderedEnumerable (keySelector, comparer, true);
2232                 }
2233
2234                 #endregion
2235
2236                 #region ToArray
2237                 public static TSource [] ToArray<TSource> (this IEnumerable<TSource> source)
2238                 {
2239                         Check.Source (source);
2240
2241                         List<TSource> list = new List<TSource> (source);
2242                         return list.ToArray ();
2243                 }
2244
2245                 #endregion
2246
2247                 #region ToDictionary
2248                 public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2249                                 Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
2250                 {
2251                         return ToDictionary<TSource, TKey, TElement> (source, keySelector, elementSelector, null);
2252                 }
2253
2254                 public static Dictionary<TKey, TElement> ToDictionary<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                         if (comparer == null)
2260                                 comparer = EqualityComparer<TKey>.Default;
2261
2262                         var dict = new Dictionary<TKey, TElement> (comparer);
2263                         foreach (var e in source)
2264                                 dict.Add (keySelector (e), elementSelector (e));
2265
2266                         return dict;
2267                 }
2268
2269                 public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source,
2270                                 Func<TSource, TKey> keySelector)
2271                 {
2272                         return ToDictionary (source, keySelector, null);
2273                 }
2274
2275                 public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source,
2276                                 Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
2277                 {
2278                         Check.SourceAndKeySelector (source, keySelector);
2279
2280                         if (comparer == null)
2281                                 comparer = EqualityComparer<TKey>.Default;
2282
2283                         var dict = new Dictionary<TKey, TSource> (comparer);
2284                         foreach (var e in source)
2285                                 dict.Add (keySelector (e), e);
2286
2287                         return dict;
2288                 }
2289
2290                 #endregion
2291
2292                 #region ToList
2293                 public static List<TSource> ToList<TSource> (this IEnumerable<TSource> source)
2294                 {
2295                         Check.Source (source);
2296
2297                         return new List<TSource> (source);
2298                 }
2299                 #endregion
2300
2301                 #region ToLookup
2302
2303                 public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
2304                 {
2305                         return ToLookup<TSource, TKey> (source, keySelector, null);
2306                 }
2307
2308                 public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source,
2309                         Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
2310                 {
2311                         Check.SourceAndKeySelector (source, keySelector);
2312
2313                         var dictionary = new Dictionary<TKey, List<TSource>> (comparer ?? EqualityComparer<TKey>.Default);
2314                         foreach (TSource element in source) {
2315                                 TKey key = keySelector (element);
2316                                 if (key == null)
2317                                         throw new ArgumentNullException ();
2318                                 if (!dictionary.ContainsKey (key))
2319                                         dictionary.Add (key, new List<TSource> ());
2320                                 dictionary [key].Add (element);
2321                         }
2322                         return new Lookup<TKey, TSource> (dictionary);
2323                 }
2324
2325                 public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2326                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
2327                 {
2328                         return ToLookup<TSource, TKey, TElement> (source, keySelector, elementSelector, null);
2329                 }
2330
2331                 public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2332                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
2333                 {
2334                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
2335
2336                         Dictionary<TKey, List<TElement>> dictionary = new Dictionary<TKey, List<TElement>> (comparer ?? EqualityComparer<TKey>.Default);
2337                         foreach (TSource element in source) {
2338                                 TKey key = keySelector (element);
2339                                 if (key == null)
2340                                         throw new ArgumentNullException ();
2341                                 if (!dictionary.ContainsKey (key))
2342                                         dictionary.Add (key, new List<TElement> ());
2343                                 dictionary [key].Add (elementSelector (element));
2344                         }
2345                         return new Lookup<TKey, TElement> (dictionary);
2346                 }
2347
2348                 #endregion
2349
2350                 #region SequenceEqual
2351
2352                 public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
2353                 {
2354                         return first.SequenceEqual (second, null);
2355                 }
2356
2357                 public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2358                 {
2359                         Check.FirstAndSecond (first, second);
2360
2361                         if (comparer == null)
2362                                 comparer = EqualityComparer<TSource>.Default;
2363
2364                         var first_enumerator = first.GetEnumerator ();
2365                         var second_enumerator = second.GetEnumerator ();
2366
2367                         while (first_enumerator.MoveNext ()) {
2368                                 if (!second_enumerator.MoveNext ())
2369                                         return false;
2370
2371                                 if (!comparer.Equals (first_enumerator.Current, second_enumerator.Current))
2372                                         return false;
2373                         }
2374
2375                         return !second_enumerator.MoveNext ();
2376                 }
2377
2378                 #endregion
2379
2380                 #region Union
2381
2382                 public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
2383                 {
2384                         Check.FirstAndSecond (first, second);
2385
2386                         return first.Union (second, null);
2387                 }
2388
2389                 public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2390                 {
2391                         Check.FirstAndSecond (first, second);
2392
2393                         if (comparer == null)
2394                                 comparer = EqualityComparer<TSource>.Default;
2395
2396                         return CreateUnionIterator (first, second, comparer);
2397                 }
2398
2399                 static IEnumerable<TSource> CreateUnionIterator<TSource> (IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2400                 {
2401                         var items = new HashSet<TSource> (comparer);
2402                         foreach (var element in first) {
2403                                 if (! items.Contains (element)) {
2404                                         items.Add (element);
2405                                         yield return element;
2406                                 }
2407                         }
2408
2409                         foreach (var element in second) {
2410                                 if (! items.Contains (element, comparer)) {
2411                                         items.Add (element);
2412                                         yield return element;
2413                                 }
2414                         }
2415                 }
2416
2417                 #endregion
2418
2419                 #region Where
2420
2421                 public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
2422                 {
2423                         Check.SourceAndPredicate (source, predicate);
2424
2425                         return CreateWhereIterator (source, predicate);
2426                 }
2427
2428                 static IEnumerable<TSource> CreateWhereIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
2429                 {
2430                         foreach (TSource element in source)
2431                                 if (predicate (element))
2432                                         yield return element;
2433                 }
2434
2435                 public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2436                 {
2437                         Check.SourceAndPredicate (source, predicate);
2438
2439                         return CreateWhereIterator (source, predicate);
2440                 }
2441
2442                 static IEnumerable<TSource> CreateWhereIterator<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2443                 {
2444                         int counter = 0;
2445                         foreach (TSource element in source) {
2446                                 if (predicate (element, counter))
2447                                         yield return element;
2448                                 counter++;
2449                         }
2450                 }
2451
2452                 #endregion
2453
2454                 class ReadOnlyCollectionOf<T> {
2455                         public static readonly ReadOnlyCollection<T> Empty = new ReadOnlyCollection<T> (new T [0]);
2456                 }
2457
2458                 internal static ReadOnlyCollection<TSource> ToReadOnlyCollection<TSource> (this IEnumerable<TSource> source)
2459                 {
2460                         if (source == null)
2461                                 return ReadOnlyCollectionOf<TSource>.Empty;
2462
2463                         var ro = source as ReadOnlyCollection<TSource>;
2464                         if (ro != null)
2465                                 return ro;
2466
2467                         return new ReadOnlyCollection<TSource> (source.ToArray<TSource> ());
2468                 }
2469         }
2470 }