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
1607                 public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source,
1608                                 Func<TSource, TKey> keySelector,
1609                                 IComparer<TKey> comparer)
1610                 {
1611                         Check.SourceAndKeySelector (source, keySelector);
1612
1613                         return new OrderedSequence<TSource, TKey> (
1614                                         source, keySelector, comparer, false);
1615                 }
1616
1617                 #endregion
1618
1619                 #region OrderByDescending
1620
1621                 public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source,
1622                                 Func<TSource, TKey> keySelector)
1623                 {
1624                         return OrderByDescending<TSource, TKey> (source, keySelector, null);
1625                 }
1626
1627
1628                 public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source,
1629                                 Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
1630                 {
1631                         Check.SourceAndKeySelector (source, keySelector);
1632
1633                         return new OrderedSequence<TSource, TKey> (
1634                                         source, keySelector, comparer, true);
1635                 }
1636
1637                 #endregion
1638
1639                 #region Range
1640
1641                 public static IEnumerable<int> Range (int start, int count)
1642                 {
1643                         if (count < 0)
1644                                 throw new ArgumentOutOfRangeException ("count");
1645
1646                         long upto = ((long) start + count) - 1;
1647
1648                         if (upto > int.MaxValue)
1649                                 throw new ArgumentOutOfRangeException ();
1650
1651                         return CreateRangeIterator (start, (int) upto);
1652                 }
1653
1654                 static IEnumerable<int> CreateRangeIterator (int start, int upto)
1655                 {
1656                         for (int i = start; i <= upto; i++)
1657                                 yield return i;
1658                 }
1659
1660                 #endregion
1661
1662                 #region Repeat
1663
1664                 public static IEnumerable<TResult> Repeat<TResult> (TResult element, int count)
1665                 {
1666                         if (count < 0)
1667                                 throw new ArgumentOutOfRangeException ();
1668
1669                         return CreateRepeatIterator (element, count);
1670                 }
1671
1672                 static IEnumerable<TResult> CreateRepeatIterator<TResult> (TResult element, int count)
1673                 {
1674                         for (int i = 0; i < count; i++)
1675                                 yield return element;
1676                 }
1677
1678                 #endregion
1679
1680
1681                 #region Reverse
1682
1683                 public static IEnumerable<TSource> Reverse<TSource> (this IEnumerable<TSource> source)
1684                 {
1685                         Check.Source (source);
1686
1687                         return CreateReverseIterator (source);
1688                 }
1689
1690                 static IEnumerable<TSource> CreateReverseIterator<TSource> (IEnumerable<TSource> source)
1691                 {
1692                         var list = new List<TSource> (source);
1693                         list.Reverse ();
1694                         return list;
1695                 }
1696
1697                 #endregion
1698
1699                 #region Select
1700
1701                 public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
1702                 {
1703                         Check.SourceAndSelector (source, selector);
1704
1705                         return CreateSelectIterator (source, selector);
1706                 }
1707
1708                 static IEnumerable<TResult> CreateSelectIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, TResult> selector)
1709                 {
1710                         foreach (TSource element in source)
1711                                 yield return selector (element);
1712                 }
1713
1714                 public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
1715                 {
1716                         Check.SourceAndSelector (source, selector);
1717
1718                         return CreateSelectIterator (source, selector);
1719                 }
1720
1721                 static IEnumerable<TResult> CreateSelectIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
1722                 {
1723                         int counter = 0;
1724                         foreach (TSource element in source) {
1725                                 yield return selector (element, counter);
1726                                 counter++;
1727                         }
1728                 }
1729
1730                 #endregion
1731
1732                 #region SelectMany
1733
1734                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
1735                 {
1736                         Check.SourceAndSelector (source, selector);
1737
1738                         return CreateSelectManyIterator (source, selector);
1739                 }
1740
1741                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
1742                 {
1743                         foreach (TSource element in source)
1744                                 foreach (TResult item in selector (element))
1745                                         yield return item;
1746                 }
1747
1748                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
1749                 {
1750                         Check.SourceAndSelector (source, selector);
1751
1752                         return CreateSelectManyIterator (source, selector);
1753                 }
1754
1755                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
1756                 {
1757                         int counter = 0;
1758                         foreach (TSource element in source) {
1759                                 foreach (TResult item in selector (element, counter))
1760                                         yield return item;
1761                                 counter++;
1762                         }
1763                 }
1764
1765                 public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
1766                         Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1767                 {
1768                         Check.SourceAndCollectionSelectors (source, collectionSelector, selector);
1769
1770                         return CreateSelectManyIterator (source, collectionSelector, selector);
1771                 }
1772
1773                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TCollection, TResult> (IEnumerable<TSource> source,
1774                         Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1775                 {
1776                         foreach (TSource element in source)
1777                                 foreach (TCollection collection in collectionSelector (element))
1778                                         yield return selector (element, collection);
1779                 }
1780
1781                 public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult> (this IEnumerable<TSource> source,
1782                         Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1783                 {
1784                         Check.SourceAndCollectionSelectors (source, collectionSelector, selector);
1785
1786                         return CreateSelectManyIterator (source, collectionSelector, selector);
1787                 }
1788
1789                 static IEnumerable<TResult> CreateSelectManyIterator<TSource, TCollection, TResult> (IEnumerable<TSource> source,
1790                         Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> selector)
1791                 {
1792                         int counter = 0;
1793                         foreach (TSource element in source)
1794                                 foreach (TCollection collection in collectionSelector (element, counter++))
1795                                         yield return selector (element, collection);
1796                 }
1797
1798                 #endregion
1799
1800                 #region Single
1801
1802                 public static TSource Single<TSource> (this IEnumerable<TSource> source)
1803                 {
1804                         Check.Source (source);
1805
1806                         bool otherElement = false;
1807                         TSource singleElement = default (TSource);
1808                         foreach (TSource element in source) {
1809                                 if (otherElement) throw new InvalidOperationException ();
1810                                 if (!otherElement) otherElement = true;
1811                                 singleElement = element;
1812                         }
1813
1814                         if (otherElement)
1815                                 return singleElement;
1816                         else
1817                                 throw new InvalidOperationException ();
1818                 }
1819
1820
1821                 public static TSource Single<TSource> (this IEnumerable<TSource> source,
1822                                 Func<TSource, bool> predicate)
1823                 {
1824                         Check.SourceAndPredicate (source, predicate);
1825
1826                         bool otherElement = false;
1827                         TSource singleElement = default (TSource);
1828                         foreach (TSource element in source) {
1829                                 if (predicate (element)) {
1830                                         if (otherElement) throw new InvalidOperationException ();
1831                                         if (!otherElement) otherElement = true;
1832                                         singleElement = element;
1833                                 }
1834                         }
1835
1836                         if (otherElement)
1837                                 return singleElement;
1838                         else
1839                                 throw new InvalidOperationException ();
1840                 }
1841
1842                 #endregion
1843
1844                 #region SingleOrDefault
1845
1846                 public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source)
1847                 {
1848                         Check.Source (source);
1849
1850                         bool otherElement = false;
1851                         TSource singleElement = default (TSource);
1852                         foreach (TSource element in source) {
1853                                 if (otherElement) throw new InvalidOperationException ();
1854                                 if (!otherElement) otherElement = true;
1855                                 singleElement = element;
1856                         }
1857
1858                         return singleElement;
1859                 }
1860
1861
1862                 public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source,
1863                                 Func<TSource, bool> predicate)
1864                 {
1865                         Check.SourceAndPredicate (source, predicate);
1866
1867                         bool otherElement = false;
1868                         TSource singleElement = default (TSource);
1869                         foreach (TSource element in source) {
1870                                 if (predicate (element)) {
1871                                         if (otherElement) throw new InvalidOperationException ();
1872                                         if (!otherElement) otherElement = true;
1873                                         singleElement = element;
1874                                 }
1875                         }
1876
1877                         return singleElement;
1878                 }
1879
1880                 #endregion
1881
1882                 #region Skip
1883
1884                 public static IEnumerable<TSource> Skip<TSource> (this IEnumerable<TSource> source, int count)
1885                 {
1886                         Check.Source (source);
1887
1888                         return CreateSkipIterator (source, count);
1889                 }
1890
1891                 static IEnumerable<TSource> CreateSkipIterator<TSource> (IEnumerable<TSource> source, int count)
1892                 {
1893                         int i = 0;
1894                         foreach (var element in source) {
1895                                 if (i++ < count)
1896                                         continue;
1897
1898                                 yield return element;
1899                         }
1900                 }
1901
1902                 #endregion
1903
1904                 #region SkipWhile
1905
1906                 public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
1907                 {
1908                         Check.SourceAndPredicate (source, predicate);
1909
1910                         return CreateSkipWhileIterator (source, predicate);
1911                 }
1912
1913                 static IEnumerable<TSource> CreateSkipWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
1914                 {
1915                         bool yield = false;
1916
1917                         foreach (TSource element in source) {
1918                                 if (yield)
1919                                         yield return element;
1920                                 else
1921                                         if (!predicate (element)) {
1922                                                 yield return element;
1923                                                 yield = true;
1924                                         }
1925                         }
1926                 }
1927
1928                 public static IEnumerable<TSource> SkipWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
1929                 {
1930                         Check.SourceAndPredicate (source, predicate);
1931
1932                         return CreateSkipWhileIterator (source, predicate);
1933                 }
1934
1935                 static IEnumerable<TSource> CreateSkipWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
1936                 {
1937                         int counter = 0;
1938                         bool yield = false;
1939
1940                         foreach (TSource element in source) {
1941                                 if (yield)
1942                                         yield return element;
1943                                 else
1944                                         if (!predicate (element, counter)) {
1945                                                 yield return element;
1946                                                 yield = true;
1947                                         }
1948                                 counter++;
1949                         }
1950                 }
1951
1952                 #endregion
1953
1954                 #region Sum
1955
1956                 public static int Sum (this IEnumerable<int> source)
1957                 {
1958                         Check.Source (source);
1959
1960                         return Sum<int, int> (source, (a, b) => a + b);
1961                 }
1962
1963                 public static int? Sum (this IEnumerable<int?> source)
1964                 {
1965                         Check.Source (source);
1966
1967                         return SumNullable<int?, int?> (source, (a, b) => a.HasValue ? a + b : a);
1968                 }
1969
1970                 public static int Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
1971                 {
1972                         Check.SourceAndSelector (source, selector);
1973
1974                         return Sum<TSource, int> (source, (a, b) => a + selector (b));
1975                 }
1976
1977                 public static int? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
1978                 {
1979                         Check.SourceAndSelector (source, selector);
1980
1981                         return SumNullable<TSource, int?> (source, (a, b) => {
1982                                 var value = selector (b);
1983                                 return value.HasValue ? a + value.Value : a;
1984                         });
1985                 }
1986
1987                 public static long Sum (this IEnumerable<long> source)
1988                 {
1989                         Check.Source (source);
1990
1991                         return Sum<long, long> (source, (a, b) => a + b);
1992                 }
1993
1994                 public static long? Sum (this IEnumerable<long?> source)
1995                 {
1996                         Check.Source (source);
1997
1998                         return SumNullable<long?, long?> (source, (a, b) => a.HasValue ? a + b : a);
1999                 }
2000
2001                 public static long Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
2002                 {
2003                         Check.SourceAndSelector (source, selector);
2004
2005                         return Sum<TSource, long> (source, (a, b) => a + selector (b));
2006                 }
2007
2008                 public static long? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
2009                 {
2010                         Check.SourceAndSelector (source, selector);
2011
2012                         return SumNullable<TSource, long?> (source, (a, b) => {
2013                                 var value = selector (b);
2014                                 return value.HasValue ? a + value.Value : a;
2015                         });
2016                 }
2017
2018                 public static double Sum (this IEnumerable<double> source)
2019                 {
2020                         Check.Source (source);
2021
2022                         return Sum<double, double> (source, (a, b) => a + b);
2023                 }
2024
2025                 public static double? Sum (this IEnumerable<double?> source)
2026                 {
2027                         Check.Source (source);
2028
2029                         return SumNullable<double?, double?> (source, (a, b) => a.HasValue ? a + b : a);
2030                 }
2031
2032                 public static double Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
2033                 {
2034                         Check.SourceAndSelector (source, selector);
2035
2036                         return Sum<TSource, double> (source, (a, b) => a + selector (b));
2037                 }
2038
2039                 public static double? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
2040                 {
2041                         Check.SourceAndSelector (source, selector);
2042
2043                         return SumNullable<TSource, double?> (source, (a, b) => {
2044                                 var value = selector (b);
2045                                 return value.HasValue ? a + value.Value : a;
2046                         });
2047                 }
2048
2049                 public static float Sum (this IEnumerable<float> source)
2050                 {
2051                         Check.Source (source);
2052
2053                         return Sum<float, float> (source, (a, b) => a + b);
2054                 }
2055
2056                 public static float? Sum (this IEnumerable<float?> source)
2057                 {
2058                         Check.Source (source);
2059
2060                         return SumNullable<float?, float?> (source, (a, b) => a.HasValue ? a + b : a);
2061                 }
2062
2063                 public static float Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
2064                 {
2065                         Check.SourceAndSelector (source, selector);
2066
2067                         return Sum<TSource, float> (source, (a, b) => a + selector (b));
2068                 }
2069
2070                 public static float? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
2071                 {
2072                         Check.SourceAndSelector (source, selector);
2073
2074                         return SumNullable<TSource, float?> (source, (a, b) => {
2075                                 var value = selector (b);
2076                                 return value.HasValue ? a + value.Value : a;
2077                         });
2078                 }
2079
2080                 public static decimal Sum (this IEnumerable<decimal> source)
2081                 {
2082                         Check.Source (source);
2083
2084                         return Sum<decimal, decimal> (source, (a, b) => a + b);
2085                 }
2086
2087                 public static decimal? Sum (this IEnumerable<decimal?> source)
2088                 {
2089                         Check.Source (source);
2090
2091                         return SumNullable<decimal?, decimal?> (source, (a, b) => a.HasValue ? a + b : a);
2092                 }
2093
2094                 public static decimal Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
2095                 {
2096                         Check.SourceAndSelector (source, selector);
2097
2098                         return Sum<TSource, decimal> (source, (a, b) => a + selector (b));
2099                 }
2100
2101                 public static decimal? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
2102                 {
2103                         Check.SourceAndSelector (source, selector);
2104
2105                         return SumNullable<TSource, decimal?> (source, (a, b) => {
2106                                 var value = selector (b);
2107                                 return value.HasValue ? a + value.Value : a;
2108                         });
2109                 }
2110
2111                 static TR Sum<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
2112                 {
2113                         TR total = default (TR);
2114                         int counter = 0;
2115                         foreach (var element in source) {
2116                                 total = selector (total, element);
2117                                 ++counter;
2118                         }
2119
2120                         if (counter == 0)
2121                                 throw new InvalidOperationException ();
2122
2123                         return total;
2124                 }
2125
2126                 static TR SumNullable<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
2127                 {
2128                         TR total = default (TR);
2129                         foreach (var element in source) {
2130                                 total = selector (total, element);
2131                         }
2132
2133                         return total;
2134                 }
2135
2136                 #endregion
2137
2138                 #region Take
2139
2140                 public static IEnumerable<TSource> Take<TSource> (this IEnumerable<TSource> source, int count)
2141                 {
2142                         Check.Source (source);
2143
2144                         return CreateTakeIterator (source, count);
2145                 }
2146
2147                 static IEnumerable<TSource> CreateTakeIterator<TSource> (IEnumerable<TSource> source, int count)
2148                 {
2149                         if (count <= 0)
2150                                 yield break;
2151
2152                         int counter = 0;
2153                         foreach (TSource element in source) {
2154                                 if (counter++ == count)
2155                                         yield break;
2156
2157                                 yield return element;
2158                         }
2159                 }
2160
2161                 #endregion
2162
2163                 #region TakeWhile
2164
2165                 public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
2166                 {
2167                         Check.SourceAndPredicate (source, predicate);
2168
2169                         return CreateTakeWhileIterator (source, predicate);
2170                 }
2171
2172                 static IEnumerable<TSource> CreateTakeWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
2173                 {
2174                         foreach (TSource element in source) {
2175                                 if (!predicate (element))
2176                                         yield break;
2177
2178                                 yield return element;
2179                         }
2180                 }
2181
2182                 public static IEnumerable<TSource> TakeWhile<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2183                 {
2184                         Check.SourceAndPredicate (source, predicate);
2185
2186                         return CreateTakeWhileIterator (source, predicate);
2187                 }
2188
2189                 static IEnumerable<TSource> CreateTakeWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2190                 {
2191                         int counter = 0;
2192                         foreach (var element in source) {
2193                                 if (!predicate (element, counter))
2194                                         yield break;
2195
2196                                 yield return element;
2197                                 counter++;
2198                         }
2199                 }
2200
2201                 #endregion
2202
2203                 #region ThenBy
2204
2205                 public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
2206                 {
2207                         return ThenBy<TSource, TKey> (source, keySelector, null);
2208                 }
2209
2210
2211                 public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2212                         Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
2213                 {
2214                         Check.SourceAndKeySelector (source, keySelector);
2215
2216                         return source.CreateOrderedEnumerable (keySelector, comparer, false);
2217                 }
2218
2219                 #endregion
2220
2221                 #region ThenByDescending
2222
2223                 public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2224                         Func<TSource, TKey> keySelector)
2225                 {
2226                         return ThenByDescending<TSource, TKey> (source, keySelector, null);
2227                 }
2228
2229
2230                 public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source,
2231                         Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
2232                 {
2233                         Check.SourceAndKeySelector (source, keySelector);
2234
2235                         return source.CreateOrderedEnumerable (keySelector, comparer, true);
2236                 }
2237
2238                 #endregion
2239
2240                 #region ToArray
2241                 public static TSource [] ToArray<TSource> (this IEnumerable<TSource> source)
2242                 {
2243                         Check.Source (source);
2244
2245                         List<TSource> list = new List<TSource> (source);
2246                         return list.ToArray ();
2247                 }
2248
2249                 #endregion
2250
2251                 #region ToDictionary
2252                 public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2253                                 Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
2254                 {
2255                         return ToDictionary<TSource, TKey, TElement> (source, keySelector, elementSelector, null);
2256                 }
2257
2258                 public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2259                                 Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
2260                 {
2261                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
2262
2263                         if (comparer == null)
2264                                 comparer = EqualityComparer<TKey>.Default;
2265
2266                         var dict = new Dictionary<TKey, TElement> (comparer);
2267                         foreach (var e in source)
2268                                 dict.Add (keySelector (e), elementSelector (e));
2269
2270                         return dict;
2271                 }
2272
2273                 public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source,
2274                                 Func<TSource, TKey> keySelector)
2275                 {
2276                         return ToDictionary (source, keySelector, null);
2277                 }
2278
2279                 public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source,
2280                                 Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
2281                 {
2282                         Check.SourceAndKeySelector (source, keySelector);
2283
2284                         if (comparer == null)
2285                                 comparer = EqualityComparer<TKey>.Default;
2286
2287                         var dict = new Dictionary<TKey, TSource> (comparer);
2288                         foreach (var e in source)
2289                                 dict.Add (keySelector (e), e);
2290
2291                         return dict;
2292                 }
2293
2294                 #endregion
2295
2296                 #region ToList
2297                 public static List<TSource> ToList<TSource> (this IEnumerable<TSource> source)
2298                 {
2299                         Check.Source (source);
2300
2301                         return new List<TSource> (source);
2302                 }
2303                 #endregion
2304
2305                 #region ToLookup
2306
2307                 public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
2308                 {
2309                         return ToLookup<TSource, TKey> (source, keySelector, null);
2310                 }
2311
2312                 public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source,
2313                         Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
2314                 {
2315                         Check.SourceAndKeySelector (source, keySelector);
2316
2317                         var dictionary = new Dictionary<TKey, List<TSource>> (comparer ?? EqualityComparer<TKey>.Default);
2318                         foreach (TSource element in source) {
2319                                 TKey key = keySelector (element);
2320                                 if (key == null)
2321                                         throw new ArgumentNullException ();
2322                                 if (!dictionary.ContainsKey (key))
2323                                         dictionary.Add (key, new List<TSource> ());
2324                                 dictionary [key].Add (element);
2325                         }
2326                         return new Lookup<TKey, TSource> (dictionary);
2327                 }
2328
2329                 public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2330                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
2331                 {
2332                         return ToLookup<TSource, TKey, TElement> (source, keySelector, elementSelector, null);
2333                 }
2334
2335                 public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source,
2336                         Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
2337                 {
2338                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
2339
2340                         Dictionary<TKey, List<TElement>> dictionary = new Dictionary<TKey, List<TElement>> (comparer ?? EqualityComparer<TKey>.Default);
2341                         foreach (TSource element in source) {
2342                                 TKey key = keySelector (element);
2343                                 if (key == null)
2344                                         throw new ArgumentNullException ();
2345                                 if (!dictionary.ContainsKey (key))
2346                                         dictionary.Add (key, new List<TElement> ());
2347                                 dictionary [key].Add (elementSelector (element));
2348                         }
2349                         return new Lookup<TKey, TElement> (dictionary);
2350                 }
2351
2352                 #endregion
2353
2354                 #region SequenceEqual
2355
2356                 public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
2357                 {
2358                         return first.SequenceEqual (second, null);
2359                 }
2360
2361                 public static bool SequenceEqual<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2362                 {
2363                         Check.FirstAndSecond (first, second);
2364
2365                         if (comparer == null)
2366                                 comparer = EqualityComparer<TSource>.Default;
2367
2368                         var first_enumerator = first.GetEnumerator ();
2369                         var second_enumerator = second.GetEnumerator ();
2370
2371                         while (first_enumerator.MoveNext ()) {
2372                                 if (!second_enumerator.MoveNext ())
2373                                         return false;
2374
2375                                 if (!comparer.Equals (first_enumerator.Current, second_enumerator.Current))
2376                                         return false;
2377                         }
2378
2379                         return !second_enumerator.MoveNext ();
2380                 }
2381
2382                 #endregion
2383
2384                 #region Union
2385
2386                 public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second)
2387                 {
2388                         Check.FirstAndSecond (first, second);
2389
2390                         return first.Union (second, null);
2391                 }
2392
2393                 public static IEnumerable<TSource> Union<TSource> (this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2394                 {
2395                         Check.FirstAndSecond (first, second);
2396
2397                         if (comparer == null)
2398                                 comparer = EqualityComparer<TSource>.Default;
2399
2400                         return CreateUnionIterator (first, second, comparer);
2401                 }
2402
2403                 static IEnumerable<TSource> CreateUnionIterator<TSource> (IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
2404                 {
2405                         var items = new HashSet<TSource> (comparer);
2406                         foreach (var element in first) {
2407                                 if (! items.Contains (element)) {
2408                                         items.Add (element);
2409                                         yield return element;
2410                                 }
2411                         }
2412
2413                         foreach (var element in second) {
2414                                 if (! items.Contains (element, comparer)) {
2415                                         items.Add (element);
2416                                         yield return element;
2417                                 }
2418                         }
2419                 }
2420
2421                 #endregion
2422
2423                 #region Where
2424
2425                 public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
2426                 {
2427                         Check.SourceAndPredicate (source, predicate);
2428
2429                         return CreateWhereIterator (source, predicate);
2430                 }
2431
2432                 static IEnumerable<TSource> CreateWhereIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
2433                 {
2434                         foreach (TSource element in source)
2435                                 if (predicate (element))
2436                                         yield return element;
2437                 }
2438
2439                 public static IEnumerable<TSource> Where<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2440                 {
2441                         Check.SourceAndPredicate (source, predicate);
2442
2443                         return CreateWhereIterator (source, predicate);
2444                 }
2445
2446                 static IEnumerable<TSource> CreateWhereIterator<TSource> (this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
2447                 {
2448                         int counter = 0;
2449                         foreach (TSource element in source) {
2450                                 if (predicate (element, counter))
2451                                         yield return element;
2452                                 counter++;
2453                         }
2454                 }
2455
2456                 #endregion
2457
2458                 class ReadOnlyCollectionOf<T> {
2459                         public static readonly ReadOnlyCollection<T> Empty = new ReadOnlyCollection<T> (new T [0]);
2460                 }
2461
2462                 internal static ReadOnlyCollection<TSource> ToReadOnlyCollection<TSource> (this IEnumerable<TSource> source)
2463                 {
2464                         if (source == null)
2465                                 return ReadOnlyCollectionOf<TSource>.Empty;
2466
2467                         var ro = source as ReadOnlyCollection<TSource>;
2468                         if (ro != null)
2469                                 return ro;
2470
2471                         return new ReadOnlyCollection<TSource> (source.ToArray<TSource> ());
2472                 }
2473         }
2474 }