From 3db1a1cddd48a2b35746c3578b150145b5324b8e Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Sun, 26 Feb 2023 21:58:23 +0100
Subject: [PATCH 1/2] Fix inconsistencies in "Fold" doc

---
 MoreLinq/Extensions.g.cs | 160 +++++++++++++++++++--------------------
 MoreLinq/Fold.g.cs       | 160 +++++++++++++++++++--------------------
 MoreLinq/Fold.g.tt       |  10 +--
 3 files changed, 165 insertions(+), 165 deletions(-)

diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index a5ca2ac81..cd9026564 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -2032,14 +2032,14 @@ public static partial class FoldExtension
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2052,14 +2052,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResu
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2072,14 +2072,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TR
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2092,14 +2092,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2112,14 +2112,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2132,14 +2132,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2152,14 +2152,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2172,14 +2172,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2192,14 +2192,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2212,14 +2212,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2232,14 +2232,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2252,14 +2252,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2272,14 +2272,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2292,14 +2292,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2312,14 +2312,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
@@ -2332,14 +2332,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
             => MoreEnumerable.Fold(source, folder);
diff --git a/MoreLinq/Fold.g.cs b/MoreLinq/Fold.g.cs
index 714c8f945..adf2ea990 100644
--- a/MoreLinq/Fold.g.cs
+++ b/MoreLinq/Fold.g.cs
@@ -30,14 +30,14 @@ partial class MoreEnumerable
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResult> folder)
         {
@@ -56,14 +56,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResu
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TResult> folder)
         {
@@ -82,14 +82,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TR
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, TResult> folder)
         {
@@ -108,14 +108,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, TResult> folder)
         {
@@ -134,14 +134,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, TResult> folder)
         {
@@ -160,14 +160,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, TResult> folder)
         {
@@ -186,14 +186,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, TResult> folder)
         {
@@ -212,14 +212,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -238,14 +238,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -264,14 +264,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -290,14 +290,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -316,14 +316,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -342,14 +342,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -368,14 +368,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -394,14 +394,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
         {
@@ -420,14 +420,14 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
         {
diff --git a/MoreLinq/Fold.g.tt b/MoreLinq/Fold.g.tt
index 41a0a1205..85d3aa133 100644
--- a/MoreLinq/Fold.g.tt
+++ b/MoreLinq/Fold.g.tt
@@ -47,14 +47,14 @@ namespace MoreLinq
         /// This operator uses immediate execution and effectively buffers
         /// as many items of the source sequence as necessary.
         /// </remarks>
-        /// <typeparam name="T">Type of element in the source sequence</typeparam>
-        /// <typeparam name="TResult">Type of the result</typeparam>
+        /// <typeparam name="T">Type of element in the source sequence.</typeparam>
+        /// <typeparam name="TResult">Type of the result.</typeparam>
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is null</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly <#= e.CountString #> <#= e.ElementNoun #></exception>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly <#= e.CountString #> <#= e.ElementNoun #>.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<<#= string.Join(", ", Enumerable.Repeat("T", e.Count)) #>, TResult> folder)
         {

From 345487f4a9ca507c7ad016ade7aa35896696b712 Mon Sep 17 00:00:00 2001
From: Atif Aziz <code@raboof.com>
Date: Sun, 26 Feb 2023 22:19:51 +0100
Subject: [PATCH 2/2] Merge null arg exception sections

---
 MoreLinq/Extensions.g.cs | 80 ++++++++++++++++++++++++----------------
 MoreLinq/Fold.g.cs       | 80 ++++++++++++++++++++++++----------------
 MoreLinq/Fold.g.tt       |  5 ++-
 3 files changed, 99 insertions(+), 66 deletions(-)

diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs
index cd9026564..4ec625245 100644
--- a/MoreLinq/Extensions.g.cs
+++ b/MoreLinq/Extensions.g.cs
@@ -2037,8 +2037,9 @@ public static partial class FoldExtension
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResult> folder)
@@ -2057,8 +2058,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResu
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TResult> folder)
@@ -2077,8 +2079,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TR
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, TResult> folder)
@@ -2097,8 +2100,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, TResult> folder)
@@ -2117,8 +2121,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, TResult> folder)
@@ -2137,8 +2142,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, TResult> folder)
@@ -2157,8 +2163,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, TResult> folder)
@@ -2177,8 +2184,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, TResult> folder)
@@ -2197,8 +2205,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -2217,8 +2226,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -2237,8 +2247,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -2257,8 +2268,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -2277,8 +2289,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -2297,8 +2310,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -2317,8 +2331,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -2337,8 +2352,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
diff --git a/MoreLinq/Fold.g.cs b/MoreLinq/Fold.g.cs
index adf2ea990..e7d64b884 100644
--- a/MoreLinq/Fold.g.cs
+++ b/MoreLinq/Fold.g.cs
@@ -35,8 +35,9 @@ partial class MoreEnumerable
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResult> folder)
@@ -61,8 +62,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, TResu
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TResult> folder)
@@ -87,8 +89,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, TR
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, TResult> folder)
@@ -113,8 +116,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, TResult> folder)
@@ -139,8 +143,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, TResult> folder)
@@ -165,8 +170,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, TResult> folder)
@@ -191,8 +197,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, TResult> folder)
@@ -217,8 +224,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, TResult> folder)
@@ -243,8 +251,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -269,8 +278,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -295,8 +305,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -321,8 +332,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -347,8 +359,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -373,8 +386,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -399,8 +413,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
@@ -425,8 +440,9 @@ public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T,
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder)
diff --git a/MoreLinq/Fold.g.tt b/MoreLinq/Fold.g.tt
index 85d3aa133..d5ce0fc74 100644
--- a/MoreLinq/Fold.g.tt
+++ b/MoreLinq/Fold.g.tt
@@ -52,8 +52,9 @@ namespace MoreLinq
         /// <param name="source">The sequence of items to fold.</param>
         /// <param name="folder">Function to apply to the elements in the sequence.</param>
         /// <returns>The folded value returned by <paramref name="folder"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="folder"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException">
+        /// Either <paramref name="source"/> or <paramref name="folder"/> is <see langword="null"/>.
+        /// </exception>
         /// <exception cref="InvalidOperationException"><paramref name="source"/> does not contain exactly <#= e.CountString #> <#= e.ElementNoun #>.</exception>
 
         public static TResult Fold<T, TResult>(this IEnumerable<T> source, Func<<#= string.Join(", ", Enumerable.Repeat("T", e.Count)) #>, TResult> folder)