Prototype collection IfAny()

src/Common/IValidatable.cs

@@ -0,0 +1,25 @@
+namespace Throw;
+
+/// <summary>
+/// asdf.
+/// </summary>
+/// <typeparam name="T">asdf.</typeparam>
+public interface IValidatable<out T>
+{
+    /// <summary>
+    /// asdf.
+    /// </summary>
+    /// <value></value>
+    T Value { get; }
+
+    /// <summary>
+    /// asdf.
+    /// </summary>
+    /// <value></value>
+    string ParamName { get; }
+
+    /// <summary>
+    /// asdf.
+    /// </summary>
+    ExceptionCustomizations? ExceptionCustomizations { get; }
+}

src/Common/Validatable.cs

@@ -7,7 +7,9 @@ namespace Throw;
 /// <param name="Value">The value to be validated.</param>
 /// <param name="ParamName">The name of the parameter holding the <paramref name="Value"/>.</param>
 /// <param name="ExceptionCustomizations">Customizations to the exception, which will be applied if an exception is thrown.</param>
-public readonly record struct Validatable<TValue>(TValue Value, string ParamName, ExceptionCustomizations? ExceptionCustomizations = null) where TValue : notnull
+public readonly record struct Validatable<TValue>(TValue Value, string ParamName, ExceptionCustomizations? ExceptionCustomizations = null)
+    : IValidatable<TValue>
+    where TValue : notnull
 {
     /// <summary>
     /// Implicit conversion operator back to the original value's type.

src/Program.cs

@@ -0,0 +1,9 @@
+using Throw;
+
+int[] collection = new[] { 1, 2, 3 };
+var collection2 = Enumerable.Range(0, 10);
+List<int> collection3 = collection2.ToList();
+
+collection.Throw().IfAny(x => x > 2);
+collection2.Throw().IfAny(x => x > 2);
+collection3.Throw().IfAny(x => x > 2);

src/Throw.csproj

@@ -6,6 +6,7 @@
     <Nullable>enable</Nullable>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <OutputType>Exe</OutputType>
   </PropertyGroup>
 
   <PropertyGroup>

src/ValidatableExtensions/ValidatableExtensions.Collections.cs

@@ -118,4 +118,19 @@ public static ref readonly Validatable<TValue> IfHasNullElements<TValue>(this in
 
         return ref validatable;
     }
+
+    /// <summary>
+    /// Throws an exception if any of the items in the collection matches the <paramref name="predicate"/>.
+    /// Important note: if the collection is a non-evaluated expression, the expression will be evaluated.
+    /// </summary>
+    /// <remarks>
+    /// The default exception thrown is an <see cref="ArgumentException"/>.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static IValidatable<IEnumerable<TItem>> IfAny<TItem>(this IValidatable<IEnumerable<TItem>> validatable, Func<TItem, bool> predicate, [CallerArgumentExpression("predicate")] string? predicateName = null)
+    {
+        Validator.ThrowIfAny(validatable.Value, predicate, predicateName!, validatable.ParamName, validatable.ExceptionCustomizations);
+
+        return validatable;
+    }
 }

src/Validators/Validator.Collections.cs

@@ -57,6 +57,19 @@ internal static void ThrowIfHasNullElements<TValue>(TValue value, string paramNa
         }
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static void ThrowIfAny<TValue, TItem>(TValue value, Func<TItem, bool> predicate, string predicateName, string paramName, ExceptionCustomizations? exceptionCustomizations)
+        where TValue : notnull, IEnumerable<TItem>
+    {
+        foreach (var item in value)
+        {
+            if (predicate(item))
+            {
+                ExceptionThrower.Throw(paramName, exceptionCustomizations, $"Collection should not have any elements matching {predicateName}.");
+            }
+        }
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static int GetCollectionCount<TValue>(TValue value)
         where TValue : notnull, IEnumerable