Simplify names (IDE0001)

MoreLinq.Test/ToDataTableTest.cs

@@ -71,7 +71,7 @@ public void ToDataTableNullMemberExpressionMethod()
             Expression<Func<TestObject, object>> expression = null;
 
             AssertThrowsArgument.Exception("expressions",() =>
-                _testObjects.ToDataTable<TestObject>(expression));
+                _testObjects.ToDataTable(expression));
         }
 
         [Test]

MoreLinq/Lookup.cs

@@ -117,7 +117,7 @@ public IEnumerable<TResult> ApplyResultSelector<TResult>(Func<TKey, IEnumerable<
             if (g != null) {
                 do {
                     g = g.next;
-                    if (g.count != g.elements.Length) { Array.Resize<TElement>(ref g.elements, g.count); }
+                    if (g.count != g.elements.Length) { Array.Resize(ref g.elements, g.count); }
                     yield return resultSelector(g.key, g.elements);
                 } while (g != _lastGrouping);
             }

MoreLinq/PartialSort.cs

@@ -43,7 +43,7 @@ public static IEnumerable<T> PartialSort<T>(this IEnumerable<T> source, int coun
         }
 
         /// <summary>
-        /// Combines <see cref="MoreEnumerable.OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, IComparer{TKey}, OrderByDirection)"/>,
+        /// Combines <see cref="OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, IComparer{TKey}, OrderByDirection)"/>,
         /// where each element is its key, and <see cref="Enumerable.Take{TSource}(IEnumerable{TSource},int)"/>
         /// in a single operation.
         /// An additional parameter specifies the direction of the sort
@@ -88,7 +88,7 @@ public static IEnumerable<T> PartialSort<T>(this IEnumerable<T> source,
         }
 
         /// <summary>
-        /// Combines <see cref="MoreEnumerable.OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, IComparer{TKey}, OrderByDirection)"/>,
+        /// Combines <see cref="OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, IComparer{TKey}, OrderByDirection)"/>,
         /// where each element is its key, and <see cref="Enumerable.Take{TSource}(IEnumerable{TSource},int)"/>
         /// in a single operation.
         /// Additional parameters specify how the elements compare to each other and
@@ -137,7 +137,7 @@ public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
         }
 
         /// <summary>
-        /// Combines <see cref="MoreEnumerable.OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, OrderByDirection)"/>,
+        /// Combines <see cref="OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, OrderByDirection)"/>,
         /// and <see cref="Enumerable.Take{TSource}(IEnumerable{TSource},int)"/> in a single operation.
         /// An additional parameter specifies the direction of the sort
         /// </summary>
@@ -188,7 +188,7 @@ public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
         }
 
         /// <summary>
-        /// Combines <see cref="MoreEnumerable.OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, OrderByDirection)"/>,
+        /// Combines <see cref="OrderBy{T, TKey}(IEnumerable{T}, Func{T, TKey}, OrderByDirection)"/>,
         /// and <see cref="Enumerable.Take{TSource}(IEnumerable{TSource},int)"/> in a single operation.
         /// Additional parameters specify how the elements compare to each other and
         /// the direction of the sort.

MoreLinq/PreScan.cs

@@ -31,7 +31,7 @@ static partial class MoreEnumerable
         /// element is a special case, it is set to the identity). More
         /// generally, the pre-scan allows any commutative binary operation,
         /// not just a sum.
-        /// The inclusive version of PreScan is <see cref="MoreEnumerable.Scan{TSource}"/>.
+        /// The inclusive version of PreScan is <see cref="Scan{TSource}"/>.
         /// This operator uses deferred execution and streams its result.
         /// </remarks>
         /// <example>

MoreLinq/Scan.cs

@@ -31,7 +31,7 @@ static partial class MoreEnumerable
         /// N-th element is the sum of the first N input elements. More
         /// generally, the scan allows any commutative binary operation, not
         /// just a sum.
-        /// The exclusive version of Scan is <see cref="MoreEnumerable.PreScan{TSource}"/>.
+        /// The exclusive version of Scan is <see cref="PreScan{TSource}"/>.
         /// This operator uses deferred execution and streams its result.
         /// </remarks>
         /// <example>

MoreLinq/ScanRight.cs

@@ -25,7 +25,7 @@ static partial class MoreEnumerable
         /// <summary>
         /// Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
         /// This operator is the right-associative version of the
-        /// <see cref="MoreEnumerable.Scan{TSource}(IEnumerable{TSource}, Func{TSource, TSource, TSource})"/> LINQ operator.
+        /// <see cref="Scan{TSource}(IEnumerable{TSource}, Func{TSource, TSource, TSource})"/> LINQ operator.
         /// </summary>
         /// <typeparam name="TSource">Type of elements in source sequence.</typeparam>
         /// <param name="source">Source sequence.</param>
@@ -60,7 +60,7 @@ public static IEnumerable<TSource> ScanRight<TSource>(this IEnumerable<TSource>
         /// Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
         /// The specified seed value is used as the initial accumulator value.
         /// This operator is the right-associative version of the
-        /// <see cref="MoreEnumerable.Scan{TSource, TState}(IEnumerable{TSource}, TState, Func{TState, TSource, TState})"/> LINQ operator.
+        /// <see cref="Scan{TSource, TState}(IEnumerable{TSource}, TState, Func{TState, TSource, TState})"/> LINQ operator.
         /// </summary>
         /// <typeparam name="TSource">The type of the elements of source.</typeparam>
         /// <typeparam name="TAccumulate">The type of the accumulator value.</typeparam>