From e6769afb3418b93ae0ad48b6425102848937e33b Mon Sep 17 00:00:00 2001
From: Your Name <you@example.com>
Date: Fri, 8 May 2026 17:01:38 +0300
Subject: [PATCH] Add span support for email validation, null/empty checks, and
 predicate guards

---
 .idea/.idea.SGuard/.idea/workspace.xml        | 102 ++++++---
 SGuard.sln.DotSettings.user                   |  17 +-
 guard/SGuard.csproj                           |   2 +-
 guard/SGuard.csproj.DotSettings               |   1 +
 guard/src/Callbacks/SGuardCallback.cs         |  16 +-
 guard/src/Common/ExceptionActivator.cs        |   2 +-
 guard/src/Guards/All/Is.All.cs                |  39 ++++
 guard/src/Guards/All/ThrowIf.All.cs           |  31 +++
 guard/src/Guards/Any/Is.Any.cs                |  42 ++++
 guard/src/Guards/Any/ThrowIf.Any.cs           |  22 ++
 guard/src/Guards/Email/Is.Email.cs            |  70 ++++++
 .../src/Guards/NullOrEmpty/Is.NullOrEmpty.cs  |  35 +++
 .../Guards/NullOrEmpty/ThrowIf.NullOrEmpty.cs |  41 +++-
 guard/src/Internal/SGuard.cs                  |   6 +-
 .../Internal/Visitor/NullOrEmptyVisitor.cs    |  15 +-
 tests/IsAllTests.cs                           |  66 +++++-
 tests/IsAnyTests.cs                           | 134 ++++++++++++
 tests/IsEmailTests.cs                         |  80 +++++++
 tests/IsNullOrEmptyTests.cs                   |  40 +++-
 tests/NullOrEmptySpanTests.cs                 |  58 +++++
 tests/SGuard.Tests.csproj                     |   2 +-
 tests/ThrowIfAllTests.cs                      | 202 ++++++++++++++++++
 tests/ThrowIfAnyTests.cs                      | 120 +++++++++++
 23 files changed, 1086 insertions(+), 57 deletions(-)
 create mode 100644 guard/src/Guards/Email/Is.Email.cs
 create mode 100644 tests/IsEmailTests.cs
 create mode 100644 tests/NullOrEmptySpanTests.cs
 create mode 100644 tests/ThrowIfAllTests.cs

diff --git a/.idea/.idea.SGuard/.idea/workspace.xml b/.idea/.idea.SGuard/.idea/workspace.xml
index a4500f4..485c304 100644
--- a/.idea/.idea.SGuard/.idea/workspace.xml
+++ b/.idea/.idea.SGuard/.idea/workspace.xml
@@ -6,10 +6,34 @@
   <component name="AutoImportSettings">
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
+  <component name="CMakeProjectFlavorService">
+    <option name="flavorId" value="CMakePlainProjectFlavor" />
+  </component>
+  <component name="CMakeSettings">
+    <configurations />
+  </component>
   <component name="ChangeListManager">
     <list default="true" id="368d2faa-bdc4-444a-898e-4c44b568d715" name="Changes" comment="">
-      <change afterPath="$PROJECT_DIR$/docs/index.html" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/SGuard.sln" beforeDir="false" afterPath="$PROJECT_DIR$/SGuard.sln" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/guard/src/Guards/Email/Is.Email.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.idea/.idea.SGuard/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/.idea.SGuard/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/SGuard.sln.DotSettings.user" beforeDir="false" afterPath="$PROJECT_DIR$/SGuard.sln.DotSettings.user" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/SGuard.csproj" beforeDir="false" afterPath="$PROJECT_DIR$/guard/SGuard.csproj" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/SGuard.csproj.DotSettings" beforeDir="false" afterPath="$PROJECT_DIR$/guard/SGuard.csproj.DotSettings" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Callbacks/SGuardCallback.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Callbacks/SGuardCallback.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Common/ExceptionActivator.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Common/ExceptionActivator.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Guards/All/Is.All.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Guards/All/Is.All.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Guards/All/ThrowIf.All.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Guards/All/ThrowIf.All.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Guards/Any/Is.Any.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Guards/Any/Is.Any.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Guards/Any/ThrowIf.Any.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Guards/Any/ThrowIf.Any.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Guards/NullOrEmpty/Is.NullOrEmpty.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Guards/NullOrEmpty/Is.NullOrEmpty.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Guards/NullOrEmpty/ThrowIf.NullOrEmpty.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Guards/NullOrEmpty/ThrowIf.NullOrEmpty.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Internal/SGuard.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Internal/SGuard.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/guard/src/Internal/Visitor/NullOrEmptyVisitor.cs" beforeDir="false" afterPath="$PROJECT_DIR$/guard/src/Internal/Visitor/NullOrEmptyVisitor.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tests/IsAllTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/tests/IsAllTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tests/IsAnyTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/tests/IsAnyTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tests/IsNullOrEmptyTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/tests/IsNullOrEmptyTests.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tests/SGuard.Tests.csproj" beforeDir="false" afterPath="$PROJECT_DIR$/tests/SGuard.Tests.csproj" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tests/ThrowIfAnyTests.cs" beforeDir="false" afterPath="$PROJECT_DIR$/tests/ThrowIfAnyTests.cs" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -19,6 +43,10 @@
   <component name="DpaMonitoringSettings">
     <option name="firstShow" value="false" />
   </component>
+  <component name="EmbeddingIndexingInfo">
+    <option name="cachedIndexableFilesCount" value="2" />
+    <option name="fileBasedEmbeddingIndicesEnabled" value="true" />
+  </component>
   <component name="FileTemplateManagerImpl">
     <option name="RECENT_TEMPLATES">
       <list>
@@ -64,26 +92,11 @@
   }
 }</component>
   <component name="HighlightingSettingsPerFile">
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/02bfa03b73f94f5b8947ec21da8cdcba74518/57/01eb8ba3/InvalidOperationException.cs" root0="SKIP_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/02bfa03b73f94f5b8947ec21da8cdcba74518/72/d214aaaf/ArgumentNullException.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/02bfa03b73f94f5b8947ec21da8cdcba74518/a4/0eaada2e/ArgumentException.cs" root0="SKIP_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/9e152ae1f1f0493cba641958893be34e6d18/98/2998a8d2/ConcurrentBag`1.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/23b393789bb834fac8f4c285f7e317cf0a0b42874eedab1321366c175116c/ArgumentException.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/5e14a4e27990972fa4ae94975603bd298aaf328ee083c03b10569ee4724d57/TestInvoker.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/5ef9e37e2f99ef2688a1586afed1cff6eef912a11aa9b20a56943a255a6e6b/RuntimeHelpers.CoreCLR.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/6d2342c247c64eb7a9b3702e481e4443f83e00/_18cae/IReadOnlyList.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/6d2342c247c64eb7a9b3702e481e4443f83e00/_73335/ITuple.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/6d2342c247c64eb7a9b3702e481e4443f83e00/_aa473/IReadOnlyCollection.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/6d2342c247c64eb7a9b3702e481e4443f83e00/_ec32c/IEnumerable.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/7370f75b31302934cf197cfba21d55cbc9a7349a116dfbd47989bf9da3ffd4c8/RuntimePropertyInfo.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/77fc0eb92b774686bbae91cb92331703d83600/_231dd/IEnumerable.cs" root0="SKIP_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/77fc0eb92b774686bbae91cb92331703d83600/_e933c/IDictionary.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/85452eea5fbc567c4fb2b148c6d551d43e9fdb14e47c52c45c97e37eab57f71/ArgumentOutOfRangeException.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/a60d29cc1da0a3ba582d76e277de74172fe7bc65eef658abbd1f31711a24/Tuple.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/ab39789ea37d758e3e8d50876435a5602cc024ea1189515a0571eb74ab1157f/XmlNodeList.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/adfc7b773ddc1b2c8c8a31541a79832a2bf2c215cae4f6e6de91c07661c89/ManualConfig.cs" root0="SKIP_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/b5b0d089f5c7786c38ca60661c1a5ae71fb467f3704e9cff2eac5af33d9d819/ArraySegment.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/baa8e7d4791cced365c9d7a682f0113b93d06e1c5c78bc63c611d852c11d83cd/INumber.cs" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/054629aa37f44443aa6189c89c7e4c087f38/16/2f50f412/Enumerable.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/285675a6903d43ca89ed13e37e2bfe3c2d4d0/02/a210bc2f/Assert.cs" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/859d232309ed43adb1a6f74c405316a17d10/d2/d1f27f01/EmailAddressAttribute.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/eb1ebc61d2a24f9f94603910cc3f861aca708/b3/0cdb784a/Span`1.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/eb1ebc61d2a24f9f94603910cc3f861aca708/e5/8cb11b64/SpanMarshaller`2.cs" root0="SKIP_HIGHLIGHTING" />
     <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/bfff78ecaa39c818519fc918bb2d4bbdca6ad93d7170f5cf325f67ccd0b97d43/BooleanAsserts.cs" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/SGuard.Benchmark/Program.cs" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/SGuard.Benchmark/src/All/Is.All.Benchmark.cs" root0="FORCE_HIGHLIGHTING" />
@@ -105,7 +118,10 @@
     <setting file="file://$PROJECT_DIR$/tests/NullOrEmptyVisitorTests.cs" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/tests/ThrowIfCallbackExceptionSwallowTests.cs" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/tests/ThrowIfNullOrEmptyTests.cs" root0="FORCE_HIGHLIGHTING" />
-    <setting file="file:///usr/local/share/dotnet/sdk/9.0.101/Sdks/NuGet.Build.Tasks.Pack/buildCrossTargeting/NuGet.Build.Tasks.Pack.targets" root0="FORCE_HIGHLIGHTING" />
+  </component>
+  <component name="McpProjectServerCommands">
+    <commands />
+    <urls />
   </component>
   <component name="MetaFilesCheckinStateConfiguration" checkMetaFiles="true" />
   <component name="ProblemsViewState">
@@ -126,19 +142,31 @@
   <component name="PropertiesComponent"><![CDATA[{
   "keyToString": {
     ".NET Project.SGuard.Benchmark.executor": "Run",
+    "7ce84f90-6ae2-4e9e-860e-eb90f45871f3.executor": "Debug",
     "ASKED_SHARE_PROJECT_CONFIGURATION_FILES": "true",
+    "RunOnceActivity.MCP Project settings loaded": "true",
     "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.TerminalTabsStorage.copyFrom.TerminalArrangementManager.252": "true",
+    "RunOnceActivity.cidr.known.project.marker": "true",
     "RunOnceActivity.git.unshallow": "true",
+    "RunOnceActivity.readMode.enableVisualFormatting": "true",
+    "RunOnceActivity.typescript.service.memoryLimit.init": "true",
+    "cidr.known.project.marker": "true",
+    "codeWithMe.voiceChat.enabledByDefault": "false",
+    "com.intellij.ml.llm.matterhorn.ej.ui.settings.DefaultModelSelectionForGA.v1": "true",
     "e101f5ea-0955-4784-a7c1-9fb078d779f7.executor": "Run",
+    "e4ed925c-df81-4281-90d3-c9f07ddd1822.executor": "Debug",
     "e8fffb31-1d21-4053-88b9-721e10f8111c.executor": "Debug",
     "f9e0363e-a8d4-4255-a860-9e56649d97e9.executor": "Debug",
-    "git-widget-placeholder": "feature/re-update-pipeline",
+    "git-widget-placeholder": "main",
+    "junie.onboarding.icon.badge.shown": "true",
     "node.js.detected.package.eslint": "true",
     "node.js.detected.package.tslint": "true",
     "node.js.selected.package.eslint": "(autodetect)",
     "node.js.selected.package.tslint": "(autodetect)",
     "nodejs_package_manager_path": "npm",
-    "settings.editor.selected.configurable": "preferences.pluginManager",
+    "settings.editor.selected.configurable": "preferences.lookFeel",
+    "to.speed.mode.migration.done": "true",
     "vue.rearranger.settings.migration": "true"
   },
   "keyToStringList": {
@@ -149,16 +177,14 @@
     ]
   }
 }]]></component>
-  <component name="RunManager">
+  <component name="RunManager" selected=".NET Project.SGuard.Benchmark">
     <configuration name="SGuard.Benchmark" type="DotNetProject" factoryName=".NET Project">
       <option name="EXE_PATH" value="" />
       <option name="PROGRAM_PARAMETERS" value="" />
       <option name="WORKING_DIRECTORY" value="" />
       <option name="PASS_PARENT_ENVS" value="1" />
-      <option name="USE_EXTERNAL_CONSOLE" value="0" />
       <option name="ENV_FILE_PATHS" value="" />
       <option name="REDIRECT_INPUT_PATH" value="" />
-      <option name="PTY_MODE" value="Auto" />
       <option name="MIXED_MODE_DEBUG" value="0" />
       <option name="USE_MONO" value="0" />
       <option name="RUNTIME_ARGUMENTS" value="" />
@@ -223,6 +249,7 @@
       <workItem from="1757833371899" duration="3276000" />
       <workItem from="1757865672177" duration="737000" />
       <workItem from="1757867199293" duration="1843000" />
+      <workItem from="1778232558019" duration="11980000" />
     </task>
     <task id="LOCAL-00001" summary="feat(guards): add GreaterThan comparison guards and improve null/empty visitor&#10;&#10;- Add Is.GreaterThan&lt;TLeft,TRight&gt; method with null guards and callback support&#10;- Add Is.GreaterThanOrEqual&lt;TLeft,TRight&gt; method with null guards and callback support  &#10;- Remove basic NullVisitor implementation&#10;- Replace with comprehensive NullOrEmptyVisitor supporting nested member access chains&#10;- Add type-specific empty checks for string, arrays, collections, dictionaries, and numeric types&#10;- Implement null-safe member chain traversal to prevent NullReferenceException on nested properties&#10;&#10;Breaking changes:&#10;- NullVisitor class removed (internal API)&#10;&#10;New APIs:&#10;- Is.GreaterThan&lt;TLeft,TRight&gt;(TLeft, TRight, SGuardCallback?) -&gt; bool&#10;- Is.GreaterThanOrEqual&lt;TLeft,TRight&gt;(TLeft, TRight, SGuardCallback?) -&gt; bool">
       <option name="closed" value="true" />
@@ -425,17 +452,30 @@
         </breakpoint>
         <line-breakpoint enabled="true" type="DotNet Breakpoints">
           <url>file://$PROJECT_DIR$/tests/IsNullOrEmptyTests.cs</url>
-          <line>82</line>
+          <line>83</line>
           <properties documentPath="$PROJECT_DIR$/tests/IsNullOrEmptyTests.cs" containingFunctionPresentation="Method 'NullOrEmpty_WithEmptyPrimitiveValues_ReturnsTrue'">
             <startOffsets>
-              <option value="2766" />
+              <option value="2852" />
             </startOffsets>
             <endOffsets>
-              <option value="2801" />
+              <option value="2887" />
             </endOffsets>
           </properties>
           <option name="timeStamp" value="7" />
         </line-breakpoint>
+        <line-breakpoint enabled="true" type="DotNet Breakpoints">
+          <url>file://$PROJECT_DIR$/tests/IsAllTests.cs</url>
+          <line>55</line>
+          <properties documentPath="$PROJECT_DIR$/tests/IsAllTests.cs" containingFunctionPresentation="Method 'All_ReturnsTrue_ForEmptySource'">
+            <startOffsets>
+              <option value="1592" />
+            </startOffsets>
+            <endOffsets>
+              <option value="1633" />
+            </endOffsets>
+          </properties>
+          <option name="timeStamp" value="9" />
+        </line-breakpoint>
       </breakpoints>
     </breakpoint-manager>
   </component>
diff --git a/SGuard.sln.DotSettings.user b/SGuard.sln.DotSettings.user
index 754f1b0..0fe46c3 100644
--- a/SGuard.sln.DotSettings.user
+++ b/SGuard.sln.DotSettings.user
@@ -3,7 +3,9 @@
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArgumentNullException_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F02bfa03b73f94f5b8947ec21da8cdcba74518_003F72_003Fd214aaaf_003FArgumentNullException_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArgumentOutOfRangeException_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003F85452eea5fbc567c4fb2b148c6d551d43e9fdb14e47c52c45c97e37eab57f71_003FArgumentOutOfRangeException_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AArraySegment_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003Fb5b0d089f5c7786c38ca60661c1a5ae71fb467f3704e9cff2eac5af33d9d819_003FArraySegment_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AAssert_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002Econfig_003FJetBrains_003FRider2026_002E1_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F285675a6903d43ca89ed13e37e2bfe3c2d4d0_003F02_003Fa210bc2f_003FAssert_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ABooleanAsserts_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003Fbfff78ecaa39c818519fc918bb2d4bbdca6ad93d7170f5cf325f67ccd0b97d43_003FBooleanAsserts_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ABooleanAsserts_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002Econfig_003FJetBrains_003FRider2026_002E1_003Fresharper_002Dhost_003FSourcesCache_003Fbfff78ecaa39c818519fc918bb2d4bbdca6ad93d7170f5cf325f67ccd0b97d43_003FBooleanAsserts_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AIDictionary_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003F77fc0eb92b774686bbae91cb92331703d83600_003F_005Fe933c_003FIDictionary_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AIEnumerable_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003F6d2342c247c64eb7a9b3702e481e4443f83e00_003F_005Fec32c_003FIEnumerable_002Ecs_002Fz_003A2_002D1/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AINumber_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003Fbaa8e7d4791cced365c9d7a682f0113b93d06e1c5c78bc63c611d852c11d83cd_003FINumber_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
@@ -15,17 +17,24 @@
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ATestInvoker_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003F5e14a4e27990972fa4ae94975603bd298aaf328ee083c03b10569ee4724d57_003FTestInvoker_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ATuple_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003Fa60d29cc1da0a3ba582d76e277de74172fe7bc65eef658abbd1f31711a24_003FTuple_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AXmlNodeList_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E2_003Fresharper_002Dhost_003FSourcesCache_003Fab39789ea37d758e3e8d50876435a5602cc024ea1189515a0571eb74ab1157f_003FXmlNodeList_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
-	<s:String x:Key="/Default/dotCover/Editor/HighlightingSourceSnapshotLocation/@EntryValue">/Users/selcuk/Library/Caches/JetBrains/Rider2025.2/resharper-host/temp/Rider/vAny/CoverageData/_SGuard.-762714354/Snapshot/snapshot.utdcvr</s:String>
+	
 	
 	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=44268315_002D02eb_002D40e0_002Dacf2_002Dbf19dd4aedc0/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" Name="All tests from &amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
   &lt;Solution /&gt;
 &lt;/SessionState&gt;</s:String>
-	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=e61d7d5f_002Decf1_002D4d6c_002D99a2_002D4e07d7e8eb15/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="All tests from &amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=7fb721f2_002D826d_002D46be_002Dba36_002Df80fa3af3f04/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="All tests from &amp;lt;tests&amp;gt;" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
+  &lt;Project Location="/home/selcuk/RiderProjects/SGuard" Presentation="&amp;lt;tests&amp;gt;" /&gt;
+&lt;/SessionState&gt;</s:String>
+	
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=e4ed925c_002Ddf81_002D4281_002D90d3_002Dc9f07ddd1822/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" Name="All_ReturnsTrue_ForEmptySource" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
+  &lt;Project Location="/home/selcuk/RiderProjects/SGuard/tests" Presentation="&amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" /&gt;
+&lt;/SessionState&gt;</s:String>
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=e61d7d5f_002Decf1_002D4d6c_002D99a2_002D4e07d7e8eb15/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" Name="All tests from &amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
   &lt;Project Location="C:\Users\selcuk.gural\Documents\GitHub\sguard\tests" Presentation="&amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" /&gt;
 &lt;/SessionState&gt;</s:String>
-	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=e8fffb31_002D1d21_002D4053_002D88b9_002D721e10f8111c/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="NullOrEmptyVisitorOptimizedTests" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=e8fffb31_002D1d21_002D4053_002D88b9_002D721e10f8111c/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" Name="NullOrEmptyVisitorOptimizedTests" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
   &lt;Project Location="/Users/selcuk/RiderProjects/sguard/tests" Presentation="&amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" /&gt;
 &lt;/SessionState&gt;</s:String>
-	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=f9e0363e_002Da8d4_002D4255_002Da860_002D9e56649d97e9/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="All tests from &amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=f9e0363e_002Da8d4_002D4255_002Da860_002D9e56649d97e9/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" Name="All tests from &amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
   &lt;Project Location="/Users/selcuk/RiderProjects/sguard/tests" Presentation="&amp;lt;tests&amp;gt;\&amp;lt;SGuard.Tests&amp;gt;" /&gt;
 &lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/guard/SGuard.csproj b/guard/SGuard.csproj
index 31f0f08..bf8a563 100644
--- a/guard/SGuard.csproj
+++ b/guard/SGuard.csproj
@@ -14,7 +14,7 @@
         <PackageTags>guard;is;throwIf;sguard;validation;dotnet;csharp;callbacks</PackageTags>
         <Description>SGuard is a lightweight guard library for .NET that offers explicit boolean checks (Is.*) and throwing guards (ThrowIf.*), a unified GuardCallback/GuardOutcome model, and richly-informative exceptions via CallerArgumentExpression for easier diagnostics. Targets net6.0/net7.0/net8.0/net9.0.
         </Description>
-        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+        <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
         <Title>SGuard</Title>
         <Authors>Selçuk Güral</Authors>
         <Company>Selçuk Güral</Company>
diff --git a/guard/SGuard.csproj.DotSettings b/guard/SGuard.csproj.DotSettings
index cd60914..9928d7a 100644
--- a/guard/SGuard.csproj.DotSettings
+++ b/guard/SGuard.csproj.DotSettings
@@ -5,6 +5,7 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=src_005Cguards_005Call/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=src_005Cguards_005Cany/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=src_005Cguards_005Cbetween/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=src_005Cguards_005Cemail/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=src_005Cguards_005Cgreaterthan/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=src_005Cguards_005Clessthan/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=src_005Cguards_005Cnullorempty/@EntryIndexedValue">True</s:Boolean>
diff --git a/guard/src/Callbacks/SGuardCallback.cs b/guard/src/Callbacks/SGuardCallback.cs
index 484efce..428277d 100644
--- a/guard/src/Callbacks/SGuardCallback.cs
+++ b/guard/src/Callbacks/SGuardCallback.cs
@@ -24,11 +24,23 @@ public static class SGuardCallbacks
     /// Invokes the action only when an outcome is Success.
     /// </summary>
     public static SGuardCallback OnSuccess(Action action)
-        => outcome => { if (outcome == GuardOutcome.Success) action(); };
+        => outcome =>
+        {
+            if (outcome == GuardOutcome.Success)
+            {
+                action();
+            }
+        };
 
     /// <summary>
     /// Invokes the action only when an outcome is Failure.
     /// </summary>
     public static SGuardCallback OnFailure(Action action)
-        => outcome => { if (outcome == GuardOutcome.Failure) action(); };
+        => outcome =>
+        {
+            if (outcome == GuardOutcome.Failure)
+            {
+                action();
+            }
+        };
 }
\ No newline at end of file
diff --git a/guard/src/Common/ExceptionActivator.cs b/guard/src/Common/ExceptionActivator.cs
index df3f3a6..2ac8850 100644
--- a/guard/src/Common/ExceptionActivator.cs
+++ b/guard/src/Common/ExceptionActivator.cs
@@ -31,7 +31,7 @@ public static TException Create<TException>(object?[]? args) where TException :
     {
         try
         {
-            return (TException?)Activator.CreateInstance(typeof(TException), args ?? Array.Empty<object>()) ??
+            return (TException?)Activator.CreateInstance(typeof(TException), args ?? []) ??
                    throw new InvalidOperationException($"Could not create instance of '{typeof(TException).FullName}'.");
         }
         catch (MissingMethodException)
diff --git a/guard/src/Guards/All/Is.All.cs b/guard/src/Guards/All/Is.All.cs
index 7b5a702..5d53574 100644
--- a/guard/src/Guards/All/Is.All.cs
+++ b/guard/src/Guards/All/Is.All.cs
@@ -1,3 +1,4 @@
+using System.Linq.Expressions;
 using System.Runtime.CompilerServices;
 
 namespace SGuard;
@@ -29,4 +30,42 @@ public static bool All<T>(IEnumerable<T> source, Func<T, bool> predicate, SGuard
         
         return result;
     }
+
+    /// <summary>
+    /// Determines whether all elements in a given span satisfy a specified condition.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the span.</typeparam>
+    /// <param name="source">The span of elements to be tested.</param>
+    /// <param name="predicate">A function that tests each element for a condition.</param>
+    /// <param name="callback">
+    /// An optional callback that is invoked with the outcome of the guard evaluation.
+    /// If all elements satisfy the condition, <see cref="GuardOutcome.Success"/> is passed; otherwise, <see cref="GuardOutcome.Failure"/> is passed.
+    /// </param>
+    /// <returns>
+    /// True if all elements in the span satisfy the condition specified by the predicate; otherwise, false.
+    /// </returns>
+    public static bool All<T>(ReadOnlySpan<T> source, Func<T, bool> predicate, SGuardCallback? callback = null)
+    {
+        if (source.IsEmpty)
+        {
+            SGuard.InvokeCallbackSafely(false, callback);
+            return false;
+        }
+        
+        ArgumentNullException.ThrowIfNull(predicate);
+        
+        foreach (var src in source)
+        {
+            if (predicate(src))
+            {
+                continue;
+            }
+            
+            SGuard.InvokeCallbackSafely(false, callback);
+            return false;
+        }
+
+        SGuard.InvokeCallbackSafely(true, callback);
+        return true;
+    }
 }
\ No newline at end of file
diff --git a/guard/src/Guards/All/ThrowIf.All.cs b/guard/src/Guards/All/ThrowIf.All.cs
index 2f78320..adfbc1b 100644
--- a/guard/src/Guards/All/ThrowIf.All.cs
+++ b/guard/src/Guards/All/ThrowIf.All.cs
@@ -49,4 +49,35 @@ public static void All<T, TException>(IEnumerable<T> source, Func<T, bool> predi
 
         SGuard.Guard(Is.All(source, predicate, callback), () => Throw.That(exception), callback);
     }
+
+    /// <summary>
+    /// Throws an exception of the specified type if all elements in the given span satisfy the provided predicate.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the span.</typeparam>
+    /// <typeparam name="TException">The type of exception to be thrown if the condition is met.</typeparam>
+    /// <param name="source">The span of elements to evaluate.</param>
+    /// <param name="predicate">The predicate to test each element of the span against.</param>
+    /// <param name="exception">The exception to be thrown if all elements satisfy the predicate.</param>
+    /// <param name="callback">
+    /// Optional callback to receive the guard evaluation outcome.
+    /// If not provided, no callback will be invoked.
+    /// </param>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if <paramref name="predicate"/> or <paramref name="exception"/> is null.
+    /// </exception>
+    /// <exception cref="TException">Thrown if all elements in the span satisfy the given predicate.</exception>
+    public static void All<T, TException>(ReadOnlySpan<T> source, Func<T, bool> predicate, [NotNull] TException exception, SGuardCallback? callback = null)
+        where TException : Exception
+    {
+        if (source.IsEmpty)
+        {
+            SGuard.Guard(false, () => Throw.That(exception), callback);
+            return;
+        }
+        
+        ArgumentNullException.ThrowIfNull(predicate);
+        ArgumentNullException.ThrowIfNull(exception);
+
+        SGuard.Guard(Is.All(source, predicate, callback), () => Throw.That(exception), callback);
+    }
 }
\ No newline at end of file
diff --git a/guard/src/Guards/Any/Is.Any.cs b/guard/src/Guards/Any/Is.Any.cs
index f80efbf..f9e36ee 100644
--- a/guard/src/Guards/Any/Is.Any.cs
+++ b/guard/src/Guards/Any/Is.Any.cs
@@ -33,4 +33,46 @@ public static bool Any<T>(IEnumerable<T> source, Func<T, bool> predicate, SGuard
         
         return result;
     }
+
+    /// <summary>
+    /// Determines whether any element of a span satisfies a condition,
+    /// with an optional callback to handle the result of the evaluation.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the span.</typeparam>
+    /// <param name="source">The span to check against the predicate.</param>
+    /// <param name="predicate">The function to test each element for a condition.</param>
+    /// <param name="callback">
+    /// An optional callback that is invoked with a <see cref="GuardOutcome"/> indicating
+    /// whether any element satisfied the condition (Success) or if none did (Failure).
+    /// </param>
+    /// <returns>
+    /// true if any elements in the span satisfy the condition specified by the predicate; otherwise, false.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if <paramref name="predicate"/> is null.
+    /// </exception>
+    public static bool Any<T>(ReadOnlySpan<T> source, Func<T, bool> predicate, SGuardCallback? callback = null)
+    {
+        if (source.IsEmpty)
+        {
+            SGuard.InvokeCallbackSafely(false, callback);
+            return false;
+        }
+        
+        ArgumentNullException.ThrowIfNull(predicate);
+
+        foreach (var src in source)
+        {
+            if (!predicate(src))
+            {
+                continue;
+            }
+            
+            SGuard.InvokeCallbackSafely(true, callback);
+            return true;
+        }
+        
+        SGuard.InvokeCallbackSafely(false, callback);
+        return false;
+    }
 }
\ No newline at end of file
diff --git a/guard/src/Guards/Any/ThrowIf.Any.cs b/guard/src/Guards/Any/ThrowIf.Any.cs
index 2d26580..4d8112f 100644
--- a/guard/src/Guards/Any/ThrowIf.Any.cs
+++ b/guard/src/Guards/Any/ThrowIf.Any.cs
@@ -40,4 +40,26 @@ public static void Any<T, TException>(IEnumerable<T> source, Func<T, bool> predi
         
         SGuard.Guard(Is.Any(source, predicate, callback), () => Throw.That(exception), callback);
     }
+
+    /// <summary>
+    /// Throws an exception if any element in the given source satisfies the specified predicate.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the source.</typeparam>
+    /// <typeparam name="TException">The type of exception to be thrown if the predicate condition is met.</typeparam>
+    /// <param name="source">The span of elements to evaluate.</param>
+    /// <param name="predicate">The predicate function to apply to each element.</param>
+    /// <param name="exception">The exception to be thrown when the predicate condition is satisfied.</param>
+    /// <param name="callback">An optional callback invoked with the guard's outcome.</param>
+    public static void Any<T, TException>(ReadOnlySpan<T> source, Func<T, bool> predicate, [NotNull] TException exception, SGuardCallback? callback = null)
+        where TException : Exception
+    {
+        if (source.IsEmpty)
+        {
+            SGuard.Guard(false, () => Throw.That(exception), callback);
+        }
+        ArgumentNullException.ThrowIfNull(predicate);
+        ArgumentNullException.ThrowIfNull(exception);
+        
+        SGuard.Guard(Is.Any(source, predicate, callback), () => Throw.That(exception), callback);
+    }
 }
\ No newline at end of file
diff --git a/guard/src/Guards/Email/Is.Email.cs b/guard/src/Guards/Email/Is.Email.cs
new file mode 100644
index 0000000..3dddd06
--- /dev/null
+++ b/guard/src/Guards/Email/Is.Email.cs
@@ -0,0 +1,70 @@
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+
+namespace SGuard;
+
+public sealed partial class Is
+{
+    /// <summary>
+    /// Validates if the provided string is a valid email address based on a predefined regular expression.
+    /// <b>This email validation pattern may not fully validate email addresses, according to RFC standards.
+    /// If you require strict RFC-compliant validation, use the method overload that accepts a custom regex pattern.</b>
+    /// Default <see cref="RegexOptions"/> is <see cref="RegexOptions.Compiled"/> and <see cref="RegexOptions.IgnoreCase"/>
+    /// </summary>
+    /// <param name="email">The string to validate as an email address.</param>
+    /// <param name="callback">
+    /// An optional callback that will be invoked with the outcome of the validation.
+    /// The callback receives a <see cref="GuardOutcome"/> indicating whether the validation succeeded or failed.
+    /// </param>
+    /// <returns>
+    /// A boolean value indicating whether the provided string is a valid email address.
+    /// Returns <c>true</c> if the string matches the email format; otherwise, <c>false</c>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool Email(string email, SGuardCallback? callback = null)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(email);
+        
+        var isEmail = DefaultRegexPattern().IsMatch(email);
+        SGuard.InvokeCallbackSafely(isEmail, callback);
+
+        return isEmail;
+    }
+
+
+    /// <summary>
+    /// Validates if the provided string is a valid email address based on the given regular expression.
+    /// </summary>
+    /// <param name="email">The string to validate as an email address.</param>
+    /// <param name="regex">The custom regular expression to be used for email validation.</param>
+    /// <param name="regexOptions">
+    /// Optional regular expression options that control the behavior of the regex matching process.
+    /// Defaults to <see cref="RegexOptions.None"/> if not provided.
+    /// </param>
+    /// <param name="callback">
+    /// An optional callback that will be invoked with the result of the validation.
+    /// The callback receives a <see cref="GuardOutcome"/> indicating whether the validation succeeded or failed.
+    /// </param>
+    /// <returns>
+    /// A boolean value indicating whether the provided string is a valid email address, according to the given regex.
+    /// Returns <c>true</c> if the string matches the custom email format; otherwise, <c>false</c>.
+    /// </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool Email(string email, string regex, RegexOptions? regexOptions = null,
+        SGuardCallback? callback = null)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(email);
+        ArgumentException.ThrowIfNullOrEmpty(regex);
+
+        var isEmail = Regex.IsMatch(email, regex, regexOptions ?? RegexOptions.None);
+
+        SGuard.InvokeCallbackSafely(isEmail, callback);
+
+        return isEmail;
+    }
+
+    [GeneratedRegex(
+        @"^(?=.{1,254}$)(?=.{1,64}@)(?!.*\.\.)(?!\.)(?!.*\.$)[A-Za-z0-9._%+-]+@(?:[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?\.)+[A-Za-z]{2,}$",
+        RegexOptions.Compiled | RegexOptions.IgnoreCase)]
+    internal static partial Regex DefaultRegexPattern();
+}
\ No newline at end of file
diff --git a/guard/src/Guards/NullOrEmpty/Is.NullOrEmpty.cs b/guard/src/Guards/NullOrEmpty/Is.NullOrEmpty.cs
index a3ea526..9644efb 100644
--- a/guard/src/Guards/NullOrEmpty/Is.NullOrEmpty.cs
+++ b/guard/src/Guards/NullOrEmpty/Is.NullOrEmpty.cs
@@ -29,6 +29,41 @@ public static bool NullOrEmpty<T>(T? value, SGuardCallback? callback = null)
 
         return result;
     }
+    
+    /// <summary>
+    /// Determines whether the specified value is null, empty, or matches a predefined empty pattern,
+    /// and optionally invokes a callback with the evaluation result.
+    /// </summary>
+    /// <typeparam name="T">The type of the value to evaluate.</typeparam>
+    /// <param name="value">The value to evaluate for null, emptiness, or empty patterns.</param>
+    /// <param name="callback">
+    /// An optional callback that is invoked with the result of the evaluation.
+    /// The callback is executed safely, ignoring any exceptions thrown during its invocation.
+    /// </param>
+    /// <returns>
+    /// <c>true</c> if the value is null, empty, or matches predefined empty patterns; otherwise, <c>false</c>.
+    /// </returns>
+    public static bool NullOrEmpty<T>(ReadOnlySpan<T> value, SGuardCallback? callback = null)
+    {
+        var result = value.IsEmpty;
+
+        if (!result)
+        {
+            result = true;
+            foreach (var item in value)
+            {
+                if (item is not null)
+                {
+                    result = false;
+                    break;
+                }
+            }
+        }
+        
+        SGuard.InvokeCallbackSafely(result, callback);
+        
+        return result;
+    }
 
     /// <summary>
     /// Determines whether the specified value is null or empty based on general patterns or a provided property selector.
diff --git a/guard/src/Guards/NullOrEmpty/ThrowIf.NullOrEmpty.cs b/guard/src/Guards/NullOrEmpty/ThrowIf.NullOrEmpty.cs
index 1950702..7e8c8f7 100644
--- a/guard/src/Guards/NullOrEmpty/ThrowIf.NullOrEmpty.cs
+++ b/guard/src/Guards/NullOrEmpty/ThrowIf.NullOrEmpty.cs
@@ -41,6 +41,37 @@ public static void NullOrEmpty<T>(T value, SGuardCallback? callback = null)
         SGuard.Guard(isNullOrEmpty, () => Throw.NullOrEmptyException(value), callback);
     }
 
+    /// <summary>
+    /// Checks if the specified ReadOnlySpan value is null or empty.
+    /// If the value is null or empty, throws a predefined exception.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the ReadOnlySpan.</typeparam>
+    /// <param name="value">The ReadOnlySpan to check for null or emptiness.</param>
+    /// <param name="callback">An optional callback to execute when the value is null or empty.</param>
+    public static void NullOrEmpty<T>(ReadOnlySpan<T> value, SGuardCallback? callback = null)
+    {
+        var isNullOrEmpty = value.IsEmpty;
+        T? firstItem = default;
+
+        if (!isNullOrEmpty)
+        {
+            firstItem = value[0];
+            isNullOrEmpty = true;
+            foreach (var item in value)
+            {
+                if (item is null)
+                {
+                    continue;
+                }
+                
+                isNullOrEmpty = false;
+                break;
+            }
+        }
+
+        SGuard.Guard(isNullOrEmpty, () => Throw.NullOrEmptyException(firstItem), callback);
+    }
+
     /// <summary>
     /// Checks if the specified value is null or empty.
     /// If the value is null or empty, throws the specified exception.
@@ -60,7 +91,7 @@ public static void NullOrEmpty<T, TException>(T value, TException exception, SGu
 
     /// <summary>
     /// Checks if the specified value is null or empty.
-    /// If the value is null or empty, throws an exception of the specified type, created using the provided constructor arguments.
+    /// If the value is null or empty, throws an exception to the specified type, created using the provided constructor arguments.
     /// </summary>
     /// <typeparam name="T">The type of the value to check.</typeparam>
     /// <typeparam name="TException">The type of the exception to throw if the value is null or empty.</typeparam>
@@ -111,7 +142,7 @@ public static void NullOrEmpty<TValue, TException>(TValue value, Expression<Func
 
     /// <summary>
     /// Checks if the specified value is null or empty based on the provided selector expression.
-    /// If the value is null or empty, throws a new exception of the specified type.
+    /// If the value is null or empty, throws a new exception to the specified type.
     /// </summary>
     /// <typeparam name="TValue">The type of the value to check.</typeparam>
     /// <typeparam name="TException">The type of the exception to throw if the value is null or empty.</typeparam>
@@ -130,7 +161,7 @@ public static void NullOrEmpty<TValue, TException>(TValue value, Expression<Func
 
     /// <summary>
     /// Checks if the specified value is null or empty based on the provided selector expression.
-    /// If the value is null or empty, throws an exception of the specified type, created using the provided constructor arguments.
+    /// If the value is null or empty, throws an exception to the specified type, created using the provided constructor arguments.
     /// </summary>
     /// <typeparam name="TValue">The type of the value to check.</typeparam>
     /// <typeparam name="TException">The type of the exception to throw if the value is null or empty.</typeparam>
@@ -160,11 +191,15 @@ public static void NullOrEmpty<TValue, TException>(TValue value, Expression<Func
     private static bool CheckNullOrEmpty<TValue>(TValue obj, Expression<Func<TValue, object?>> valueExpression)
     {
         if (NullOrEmptyVisitor.Visit(valueExpression) is not Expression<Func<TValue, object?>> expression)
+        {
             throw new InvalidOperationException("Unable to process the expression.");
+        }
 
         // Limit cache to avoid memory leak
         if (CompiledExpressionCache.Count > MaxCompiledExpressionCacheSize)
+        {
             CompiledExpressionCache.Clear();
+        }
 
         var func = (Func<TValue, object?>)CompiledExpressionCache.GetOrAdd(expression, exp => ((Expression<Func<TValue, object?>>)exp).Compile());
 
diff --git a/guard/src/Internal/SGuard.cs b/guard/src/Internal/SGuard.cs
index 67c4961..078aee1 100644
--- a/guard/src/Internal/SGuard.cs
+++ b/guard/src/Internal/SGuard.cs
@@ -13,7 +13,7 @@ internal static class SGuard
 {
     /// <summary>
     /// Enforces a guard clause that throws an exception if a specified condition is met.
-    /// When occur an exception during the callback invocation, the exception is ignored.
+    /// When occurs an exception during the callback invocation, the exception is ignored.
     /// </summary>
     /// <param name="condition">The condition to evaluate. If true, the specified exception-throwing action will be invoked.</param>
     /// <param name="throwAction">The action to execute if the condition is met, typically throwing an exception.</param>
@@ -36,7 +36,7 @@ public static void Guard([DoesNotReturnIf(true)] bool condition, Action throwAct
 
     /// <summary>
     /// Invokes the specified callback safely while handling any exceptions that may occur during the invocation.
-    /// When occur an exception during the callback invocation, the exception is ignored.
+    /// When occurs an exception during the callback invocation, the exception is ignored.
     /// </summary>
     /// <param name="condition">The condition to evaluate. Determines which outcome will be passed to the callback.</param>
     /// <param name="callback">An optional callback to be invoked with the outcome of the condition evaluation.</param>
@@ -45,7 +45,7 @@ public static void Guard([DoesNotReturnIf(true)] bool condition, Action throwAct
 
     /// <summary>
     /// Invokes the specified callback safely while handling any exceptions that may occur during the invocation.
-    /// When occur an exception during the callback invocation, the exception is ignored.
+    /// When occurs an exception during the callback invocation, the exception is ignored.
     /// </summary>
     /// <param name="condition">The condition used to determine the outcome passed to the callback.</param>
     /// <param name="callback">The callback to be invoked. Receives the outcome based on the provided condition.</param>
diff --git a/guard/src/Internal/Visitor/NullOrEmptyVisitor.cs b/guard/src/Internal/Visitor/NullOrEmptyVisitor.cs
index b582599..edb9c1a 100644
--- a/guard/src/Internal/Visitor/NullOrEmptyVisitor.cs
+++ b/guard/src/Internal/Visitor/NullOrEmptyVisitor.cs
@@ -30,7 +30,10 @@ protected override Expression VisitMember(MemberExpression node)
         var members = new List<MemberExpression>();
 
         for (var current = node; current is not null; current = current.Expression as MemberExpression)
+        {
             members.Add(current);
+        }
+        
         members.Reverse();
 
         var instance = members[0].Expression!;
@@ -74,7 +77,7 @@ private static Expression BuildNullOrEmptyCheckExpression(Expression memberAcces
 
         if (memberType == typeof(string))
         {
-            var method = typeof(string).GetMethod(nameof(string.IsNullOrEmpty), new[] { typeof(string) });
+            var method = typeof(string).GetMethod(nameof(string.IsNullOrEmpty), [typeof(string)]);
             specificCheck = Expression.Call(method!, memberAccess);
         }
         else if (memberType.IsArray)
@@ -89,10 +92,10 @@ private static Expression BuildNullOrEmptyCheckExpression(Expression memberAcces
             specificCheck = Expression.Equal(Expression.Property(Expression.Convert(memberAccess, typeof(ICollection)), countProp!),
                                              Expression.Constant(0));
         }
-        else if (ImplementsGenericInterface(memberType, typeof(IReadOnlyCollection<>), out var iroc))
+        else if (ImplementsGenericInterface(memberType, typeof(IReadOnlyCollection<>), out var roCollection))
         {
-            var countProp = CountPropertyCache.GetOrAdd(iroc!, t => t.GetProperty(nameof(IReadOnlyCollection<object>.Count)));
-            specificCheck = Expression.Equal(Expression.Property(Expression.Convert(memberAccess, iroc), countProp!), Expression.Constant(0));
+            var countProp = CountPropertyCache.GetOrAdd(roCollection!, t => t.GetProperty(nameof(IReadOnlyCollection<object>.Count)));
+            specificCheck = Expression.Equal(Expression.Property(Expression.Convert(memberAccess, roCollection!), countProp!), Expression.Constant(0));
         }
         else if (typeof(IDictionary).IsAssignableFrom(memberType))
         {
@@ -104,7 +107,7 @@ private static Expression BuildNullOrEmptyCheckExpression(Expression memberAcces
         else if (ImplementsGenericInterface(memberType, typeof(IReadOnlyDictionary<,>), out var irod))
         {
             var countProp = CountPropertyCache.GetOrAdd(irod!, t => t.GetProperty(nameof(IReadOnlyDictionary<object, object>.Count)));
-            specificCheck = Expression.Equal(Expression.Property(Expression.Convert(memberAccess, irod), countProp!), Expression.Constant(0));
+            specificCheck = Expression.Equal(Expression.Property(Expression.Convert(memberAccess, irod!), countProp!), Expression.Constant(0));
         }
         else if (typeof(IEnumerable).IsAssignableFrom(memberType) && memberType != typeof(string))
         {
@@ -121,7 +124,7 @@ private static Expression BuildNullOrEmptyCheckExpression(Expression memberAcces
                 var assignEnum =
                     Expression.Assign(enumeratorVar, Expression.Call(Expression.Convert(memberAccess, typeof(IEnumerable)), getEnumeratorMethod!));
                 var moveNextCall = Expression.Call(enumeratorVar, moveNextMethod!);
-                var block = Expression.Block(new[] { enumeratorVar }, assignEnum, Expression.IsFalse(moveNextCall));
+                var block = Expression.Block([enumeratorVar], assignEnum, Expression.IsFalse(moveNextCall));
                 specificCheck = block;
             }
         }
diff --git a/tests/IsAllTests.cs b/tests/IsAllTests.cs
index deedf0a..f24b703 100644
--- a/tests/IsAllTests.cs
+++ b/tests/IsAllTests.cs
@@ -21,7 +21,7 @@ public void All_ReturnsFalse_WhenAnyElementDoesNotSatisfyPredicate()
     [Fact]
     public void All_ThrowsArgumentNullException_WhenSourceIsNull()
     {
-        Assert.Throws<ArgumentNullException>(() => Is.All<int>(null!, x => true));
+        Assert.Throws<ArgumentNullException>(() => Is.All<int>((IEnumerable<int>)null!, x => true));
     }
 
     [Fact]
@@ -50,13 +50,75 @@ public void All_InvokesCallbackWithFailure_WhenAnyElementDoesNotSatisfyPredicate
     }
 
     [Fact]
-    public void All_ReturnsTrue_ForEmptySource()
+    public void All_ReturnsFalse_ForEmptySource()
     {
         var source = Array.Empty<int>();
         bool result = Is.All(source, x => false);
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void All_Span_ReturnsTrue_WhenAllElementsSatisfyPredicate()
+    {
+        int[] source = { 2, 4, 6 };
+        bool result = Is.All(source.AsSpan(), x => x % 2 == 0);
         Assert.True(result);
     }
 
+    [Fact]
+    public void All_Span_ReturnsFalse_WhenAnyElementDoesNotSatisfyPredicate()
+    {
+        int[] source = { 2, 3, 6 };
+        bool result = Is.All(source.AsSpan(), x => x % 2 == 0);
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void All_Span_ReturnsFalse_WhenSourceIsEmpty()
+    {
+        var source = Span<int>.Empty;
+        bool result = Is.All(source, x => true);
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void All_Span_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        int[] source = { 1, 2, 3 };
+        Assert.Throws<ArgumentNullException>(() =>
+        {
+            var span = source.AsSpan();
+            return Is.All(span, null!);
+        });
+    }
+
+    [Fact]
+    public void All_Span_InvokesCallbackWithSuccess_WhenAllElementsSatisfyPredicate()
+    {
+        int[] source = { 1, 1, 1 };
+        GuardOutcome? outcome = null;
+        Is.All(source.AsSpan(), x => x == 1, o => outcome = o);
+        Assert.Equal(GuardOutcome.Success, outcome);
+    }
+
+    [Fact]
+    public void All_Span_InvokesCallbackWithFailure_WhenAnyElementDoesNotSatisfyPredicate()
+    {
+        int[] source = { 1, 2, 1 };
+        GuardOutcome? outcome = null;
+        Is.All(source.AsSpan(), x => x == 1, o => outcome = o);
+        Assert.Equal(GuardOutcome.Failure, outcome);
+    }
+
+    [Fact]
+    public void All_Span_InvokesCallbackWithFailure_WhenSourceIsEmpty()
+    {
+        var source = Span<int>.Empty;
+        GuardOutcome? outcome = null;
+        Is.All(source, x => true, o => outcome = o);
+        Assert.Equal(GuardOutcome.Failure, outcome);
+    }
+
     [Fact]
     public void All_DoesNotThrow_WhenCallbackIsNull()
     {
diff --git a/tests/IsAnyTests.cs b/tests/IsAnyTests.cs
index 3e80156..d7d0a40 100644
--- a/tests/IsAnyTests.cs
+++ b/tests/IsAnyTests.cs
@@ -559,6 +559,140 @@ public void Any_EvaluatesUntilMatch_WhenMatchInMiddle()
 
     #endregion
 
+    #region Span<T> Overload Tests
+
+    [Fact]
+    public void Any_Span_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        // Arrange
+        Func<int, bool>? nullPredicate = null;
+
+        // Act & Assert
+        var exception = Assert.Throws<ArgumentNullException>(
+            () =>
+            {
+                Span<int> source = stackalloc int[] { 1, 2, 3 };
+                Is.Any(source, nullPredicate!);
+            });
+        
+        Assert.Equal("predicate", exception.ParamName);
+    }
+
+    [Fact]
+    public void Any_Span_ReturnsTrue_WhenAtLeastOneElementSatisfiesPredicate()
+    {
+        // Arrange
+        Span<int> source = stackalloc int[] { 1, 2, 3, 4, 5 };
+        Func<int, bool> predicate = x => x > 3;
+
+        // Act
+        var result = Is.Any(source, predicate);
+
+        // Assert
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void Any_Span_ReturnsFalse_WhenNoElementSatisfiesPredicate()
+    {
+        // Arrange
+        Span<int> source = stackalloc int[] { 1, 2, 3 };
+        Func<int, bool> predicate = x => x > 5;
+
+        // Act
+        var result = Is.Any(source, predicate);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void Any_Span_ReturnsFalse_WhenSourceIsEmpty()
+    {
+        // Arrange
+        Span<int> source = Span<int>.Empty;
+        Func<int, bool> predicate = x => x > 0;
+
+        // Act
+        var result = Is.Any(source, predicate);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void Any_Span_InvokesCallback_WithSuccessOutcome_WhenPredicateMatches()
+    {
+        // Arrange
+        Span<int> source = stackalloc int[] { 1, 2, 3, 4, 5 };
+        Func<int, bool> predicate = x => x > 3;
+        GuardOutcome? callbackOutcome = null;
+        SGuardCallback callback = outcome => callbackOutcome = outcome;
+
+        // Act
+        var result = Is.Any(source, predicate, callback);
+
+        // Assert
+        Assert.True(result);
+        Assert.Equal(GuardOutcome.Success, callbackOutcome);
+    }
+
+    [Fact]
+    public void Any_Span_InvokesCallback_WithFailureOutcome_WhenNoPredicateMatches()
+    {
+        // Arrange
+        Span<int> source = stackalloc int[] { 1, 2, 3 };
+        Func<int, bool> predicate = x => x > 5;
+        GuardOutcome? callbackOutcome = null;
+        SGuardCallback callback = outcome => callbackOutcome = outcome;
+
+        // Act
+        var result = Is.Any(source, predicate, callback);
+
+        // Assert
+        Assert.False(result);
+        Assert.Equal(GuardOutcome.Failure, callbackOutcome);
+    }
+
+    [Fact]
+    public void Any_Span_InvokesCallback_WithFailureOutcome_WhenSourceIsEmpty()
+    {
+        // Arrange
+        Span<int> source = Span<int>.Empty;
+        Func<int, bool> predicate = x => x > 0;
+        GuardOutcome? callbackOutcome = null;
+        SGuardCallback callback = outcome => callbackOutcome = outcome;
+
+        // Act
+        var result = Is.Any(source, predicate, callback);
+
+        // Assert
+        Assert.False(result);
+        Assert.Equal(GuardOutcome.Failure, callbackOutcome);
+    }
+
+    [Fact]
+    public void Any_Span_ShortCircuits_WhenFirstElementMatches()
+    {
+        // Arrange
+        var evaluationCount = 0;
+        Span<int> source = stackalloc int[] { 1, 2, 3, 4, 5 };
+        Func<int, bool> predicate = x =>
+        {
+            evaluationCount++;
+            return x == 1; // First element matches
+        };
+
+        // Act
+        var result = Is.Any(source, predicate);
+
+        // Assert
+        Assert.True(result);
+        Assert.Equal(1, evaluationCount); // Should only evaluate first element
+    }
+
+    #endregion
+
     #region Integration with LINQ Tests
 
     [Fact]
diff --git a/tests/IsEmailTests.cs b/tests/IsEmailTests.cs
new file mode 100644
index 0000000..c6ecd0c
--- /dev/null
+++ b/tests/IsEmailTests.cs
@@ -0,0 +1,80 @@
+namespace SGuard.Tests;
+
+public sealed class IsEmailTests
+{
+    [Theory]
+    [InlineData("plainaddress")]
+    [InlineData("#@%^%#$@#$@#.com")]
+    [InlineData("@example.com")]
+    [InlineData("Joe Smith <email@example.com>")]
+    [InlineData("email.example.com")]
+    [InlineData("email@example@example.com")]
+    [InlineData(".email@example.com")]
+    [InlineData("email..email@example.com")]
+    [InlineData("あいうえお@example.com")]
+    [InlineData("email@example.com (Joe Smith)")]
+    [InlineData("email@example")]
+    [InlineData("email@-example.com")]
+    [InlineData("email@111.222.333.44444")]
+    [InlineData("email@example..com")]
+    [InlineData("Abc..123@example.com")]
+    public void Email_ReturnsFalse_ForInvalidEmails(string email)
+    {
+        Assert.False(Is.Email(email));
+    }
+
+    [Fact]
+    public void Email_Throws_WhenValueIsNullOrEmpty()
+    {
+        Assert.Throws<ArgumentNullException>(() => Is.Email(null!));
+        Assert.Throws<ArgumentException>(() => Is.Email(string.Empty));
+    }
+
+    [Fact]
+    public void Email_WithCustomRegex_ReturnsTrue_WhenMatches()
+    {
+        var email = "test@example.com";
+        var regex = @"^.*@.*$"; // Simple regex
+        Assert.True(Is.Email(email, regex));
+    }
+
+    [Fact]
+    public void Email_WithCustomRegex_ReturnsFalse_WhenDoesNotMatch()
+    {
+        var email = "test_example.com";
+        var regex = @"^.*@.*$";
+        Assert.False(Is.Email(email, regex));
+    }
+
+    [Fact]
+    public void Email_WithCustomRegex_Throws_WhenRegexIsNullOrEmpty()
+    {
+        Assert.Throws<ArgumentException>(() => Is.Email("test@example.com", regex: string.Empty));
+        Assert.Throws<ArgumentNullException>(() => Is.Email("test@example.com", regex: null!));
+    }
+
+    [Fact]
+    public void Email_InvokesCallback()
+    {
+        bool? observed = null;
+        SGuardCallback cb = outcome => observed = outcome == GuardOutcome.Success;
+
+        Is.Email("test@example.com", cb);
+        Assert.True(observed);
+
+        Is.Email("invalid", cb);
+        Assert.False(observed);
+    }
+
+    [Fact]
+    public void Email_DoesNotThrow_WhenCallbackThrows()
+    {
+        SGuardCallback cb = _ => throw new InvalidOperationException("boom");
+        
+        var result1 = Is.Email("test@example.com", cb);
+        Assert.True(result1);
+
+        var result2 = Is.Email("invalid", cb);
+        Assert.False(result2);
+    }
+}
diff --git a/tests/IsNullOrEmptyTests.cs b/tests/IsNullOrEmptyTests.cs
index 1957138..947af90 100644
--- a/tests/IsNullOrEmptyTests.cs
+++ b/tests/IsNullOrEmptyTests.cs
@@ -60,9 +60,10 @@ private class ReadOnlyDictionaryWrapper<TKey, TValue> : IReadOnlyDictionary<TKey
     public void NullOrEmpty_WithNullValue_ReturnsTrue()
     {
         // Arrange & Act & Assert
-        Assert.True(Is.NullOrEmpty<string>(null));
-        Assert.True(Is.NullOrEmpty<int?>(null));
-        Assert.True(Is.NullOrEmpty<TestClass>(null));
+        Assert.True(Is.NullOrEmpty<string>((string?)null));
+        Assert.True(Is.NullOrEmpty<int?>((int?)null));
+        Assert.True(Is.NullOrEmpty<TestClass>((TestClass?)null));
+        Assert.True(Is.NullOrEmpty<int>(Span<int>.Empty));
     }
 
     [Theory]
@@ -89,6 +90,13 @@ public void NullOrEmpty_WithEmptyString_ReturnsTrue()
         Assert.True(Is.NullOrEmpty(""));
         Assert.True(Is.NullOrEmpty(string.Empty));
     }
+    
+    [Fact]
+    public void NullOrEmpty_WithSpanString_ReturnsTrue()
+    {
+        Assert.True(Is.NullOrEmpty(Span<char>.Empty));
+        Assert.True(Is.NullOrEmpty(Span<string>.Empty));
+    }
 
     [Fact]
     public void NullOrEmpty_WithNonEmptyString_ReturnsFalse()
@@ -97,6 +105,32 @@ public void NullOrEmpty_WithNonEmptyString_ReturnsFalse()
         Assert.False(Is.NullOrEmpty(" "));
         Assert.False(Is.NullOrEmpty("   "));
     }
+    
+    [Fact]
+    public void NullOrEmpty_WithNonEmptySpanString_ReturnsFalse()
+    {
+        var spanA = new Span<string>(["a"]);
+        Assert.False(Is.NullOrEmpty(spanA));
+        
+        var spanB = new Span<string>(["a", "b"]);
+        Assert.False(Is.NullOrEmpty(spanB));
+        
+        var spanC = new Span<char>(['c']);
+        Assert.False(Is.NullOrEmpty(spanC));
+    }
+    
+    [Fact]
+    public void NullOrEmpty_WithNonEmptySpanInteger_ReturnsFalse()
+    {
+        var spanA = new Span<int>([1]);
+        Assert.False(Is.NullOrEmpty(spanA));
+        
+        var spanB = new Span<long>([1]);
+        Assert.False(Is.NullOrEmpty(spanB));
+        
+        var spanC = new Span<byte>([1]);
+        Assert.False(Is.NullOrEmpty(spanC));
+    }
 
     [Fact]
     public void NullOrEmpty_WithBooleanValues_BehavesCorrectly()
diff --git a/tests/NullOrEmptySpanTests.cs b/tests/NullOrEmptySpanTests.cs
new file mode 100644
index 0000000..c0ee0bd
--- /dev/null
+++ b/tests/NullOrEmptySpanTests.cs
@@ -0,0 +1,58 @@
+using SGuard;
+using SGuard.Exceptions;
+
+namespace SGuard.Tests;
+
+public class NullOrEmptySpanTests
+{
+    [Fact]
+    public void NullOrEmpty_Span_WithEmptySpan_ThrowsException()
+    {
+        // Arrange
+        var emptyArray = Array.Empty<string>();
+
+        // Act & Assert
+        Assert.Throws<NullOrEmptyException>(() => 
+        {
+             ThrowIf.NullOrEmpty((ReadOnlySpan<string>)emptyArray);
+        });
+    }
+
+    [Fact]
+    public void NullOrEmpty_Span_WithAllNulls_ThrowsException()
+    {
+        // Arrange
+        var array = new string[] { null, null };
+
+        // Act & Assert
+        Assert.Throws<NullOrEmptyException>(() => 
+        {
+            ThrowIf.NullOrEmpty((ReadOnlySpan<string>)array);
+        });
+    }
+
+    [Fact]
+    public void NullOrEmpty_Span_WithItems_DoesNotThrow()
+    {
+        // Arrange
+        var span = (ReadOnlySpan<string>)new string[] { "test" };
+
+        // Act
+        ThrowIf.NullOrEmpty(span);
+
+        // Assert
+        // No exception
+    }
+    [Fact]
+    public void Is_NullOrEmpty_Span_WithAllNulls_ReturnsTrue()
+    {
+        // Arrange
+        var array = new string[] { null, null };
+
+        // Act
+        var result = Is.NullOrEmpty((ReadOnlySpan<string>)array);
+
+        // Assert
+        Assert.True(result);
+    }
+}
diff --git a/tests/SGuard.Tests.csproj b/tests/SGuard.Tests.csproj
index 0d302f9..4648541 100644
--- a/tests/SGuard.Tests.csproj
+++ b/tests/SGuard.Tests.csproj
@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net9.0;net8.0</TargetFrameworks>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <IsPackable>false</IsPackable>
         <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
         <RootNamespace>SGuard.Tests</RootNamespace>
         <AssemblyName>SGuard.Tests</AssemblyName>
+        <TargetFramework>net10.0</TargetFramework>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/tests/ThrowIfAllTests.cs b/tests/ThrowIfAllTests.cs
new file mode 100644
index 0000000..71fb072
--- /dev/null
+++ b/tests/ThrowIfAllTests.cs
@@ -0,0 +1,202 @@
+using SGuard.Exceptions;
+
+namespace SGuard.Tests;
+
+public sealed class ThrowIfAllTests
+{
+    private class CustomException : Exception
+    {
+        public CustomException() : base("Custom exception") { }
+        public CustomException(string message) : base(message) { }
+    }
+
+    #region All<T, TException>(Span<T> source, Func<T, bool> predicate, TException exception, SGuardCallback? callback = null)
+
+    [Fact]
+    public void All_Span_ThrowsCustomException_WhenAllElementsSatisfyPredicate()
+    {
+        // Arrange
+        int[] source = { 2, 4, 6 };
+        Func<int, bool> predicate = x => x % 2 == 0;
+        var customException = new CustomException("All are even");
+
+        // Act & Assert
+        var exception = Assert.Throws<CustomException>(() => 
+        {
+            var span = source.AsSpan();
+            ThrowIf.All(span, predicate, customException);
+        });
+
+        Assert.Equal("All are even", exception.Message);
+        Assert.Same(customException, exception);
+    }
+
+    [Fact]
+    public void All_Span_DoesNotThrow_WhenAnyElementDoesNotSatisfyPredicate()
+    {
+        // Arrange
+        int[] source = { 2, 3, 6 };
+        Func<int, bool> predicate = x => x % 2 == 0;
+        var customException = new CustomException();
+
+        // Act & Assert - Should not throw
+        var span = source.AsSpan();
+        ThrowIf.All(span, predicate, customException);
+    }
+
+    [Fact]
+    public void All_Span_DoesNotThrow_WhenSourceIsEmpty()
+    {
+        // Arrange
+        var source = Span<int>.Empty;
+        Func<int, bool> predicate = x => true;
+        var customException = new CustomException();
+
+        // Act & Assert - Should not throw
+        ThrowIf.All(source, predicate, customException);
+    }
+
+    [Fact]
+    public void All_Span_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        // Arrange
+        int[] source = { 1, 2, 3 };
+        var customException = new CustomException();
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => 
+        {
+            var span = source.AsSpan();
+            ThrowIf.All(span, (Func<int, bool>)null!, customException);
+        });
+    }
+
+    [Fact]
+    public void All_Span_ThrowsArgumentNullException_WhenExceptionIsNull()
+    {
+        // Arrange
+        int[] source = { 1, 2, 3 };
+        Func<int, bool> predicate = x => true;
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => 
+        {
+            var span = source.AsSpan();
+            ThrowIf.All(span, predicate, (CustomException)null!);
+        });
+    }
+
+    [Fact]
+    public void All_Span_InvokesCallbackWithFailure_WhenAllElementsSatisfyPredicate()
+    {
+        // Arrange
+        int[] source = { 1, 1, 1 };
+        Func<int, bool> predicate = x => x == 1;
+        var customException = new CustomException();
+        GuardOutcome? outcome = null;
+
+        // Act & Assert
+        Assert.Throws<CustomException>(() => 
+        {
+            var span = source.AsSpan();
+            ThrowIf.All(span, predicate, customException, o => outcome = o);
+        });
+
+        Assert.Equal(GuardOutcome.Failure, outcome);
+    }
+
+    [Fact]
+    public void All_Span_InvokesCallbackWithSuccess_WhenAnyElementDoesNotSatisfyPredicate()
+    {
+        // Arrange
+        int[] source = { 1, 2, 1 };
+        Func<int, bool> predicate = x => x == 1;
+        var customException = new CustomException();
+        GuardOutcome? outcome = null;
+
+        // Act
+        var span = source.AsSpan();
+        ThrowIf.All(span, predicate, customException, o => outcome = o);
+
+        // Assert
+        Assert.Equal(GuardOutcome.Success, outcome);
+    }
+
+    [Fact]
+    public void All_Span_InvokesCallbackWithSuccess_WhenSourceIsEmpty()
+    {
+        // Arrange
+        var source = Span<int>.Empty;
+        Func<int, bool> predicate = x => true;
+        var customException = new CustomException();
+        GuardOutcome? outcome = null;
+
+        // Act
+        ThrowIf.All(source, predicate, customException, o => outcome = o);
+
+        // Assert
+        Assert.Equal(GuardOutcome.Success, outcome);
+    }
+
+    #endregion
+
+    #region All<T, TException>(IEnumerable<T> source, Func<T, bool> predicate, TException exception, SGuardCallback? callback = null)
+
+    [Fact]
+    public void All_Enumerable_ThrowsCustomException_WhenAllElementsSatisfyPredicate()
+    {
+        // Arrange
+        var source = new[] { 2, 4, 6 };
+        Func<int, bool> predicate = x => x % 2 == 0;
+        var customException = new CustomException("All are even");
+
+        // Act & Assert
+        var exception = Assert.Throws<CustomException>(() => ThrowIf.All(source, predicate, customException));
+        Assert.Same(customException, exception);
+    }
+
+    [Fact]
+    public void All_Enumerable_DoesNotThrow_WhenAnyElementDoesNotSatisfyPredicate()
+    {
+        // Arrange
+        var source = new[] { 2, 3, 6 };
+        Func<int, bool> predicate = x => x % 2 == 0;
+        var customException = new CustomException();
+
+        // Act & Assert - Should not throw
+        ThrowIf.All(source, predicate, customException);
+    }
+
+    [Fact]
+    public void All_Enumerable_DoesNotThrow_WhenSourceIsEmpty()
+    {
+        // Arrange
+        var source = Array.Empty<int>();
+        Func<int, bool> predicate = x => true;
+        var customException = new CustomException();
+
+        // Act & Assert - Should not throw
+        // NOTE: In previous session notes, it was mentioned that Is.All returns false for empty source.
+        // Even though LINQ's Enumerable.All returns true, SGuard's Is.All might be handling empty differently
+        // OR ThrowIf.All has its own logic.
+        ThrowIf.All(source, predicate, customException);
+    }
+
+    #endregion
+
+    #region All<T>(IEnumerable<T> source, Func<T, bool> predicate, SGuardCallback? callback = null)
+
+    [Fact]
+    public void All_ThrowsAllException_WhenAllElementsSatisfyPredicate()
+    {
+        // Arrange
+        var source = new[] { 1, 1, 1 };
+        Func<int, bool> predicate = x => x == 1;
+
+        // Act & Assert
+        var exception = Assert.Throws<AllException>(() => ThrowIf.All(source, predicate));
+        Assert.Equal("All elements satisfied the given predicate.", exception.Message);
+    }
+
+    #endregion
+}
diff --git a/tests/ThrowIfAnyTests.cs b/tests/ThrowIfAnyTests.cs
index a6d5f4d..2c705d6 100644
--- a/tests/ThrowIfAnyTests.cs
+++ b/tests/ThrowIfAnyTests.cs
@@ -203,6 +203,126 @@ public void Any_Generic_WorksWithComplexObjects()
 
     #endregion
 
+    #region Any<T, TException>(Span<T> source, Func<T, bool> predicate, TException exception, SGuardCallback? callback = null)
+
+    [Fact]
+    public void Any_Span_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        // Arrange
+        Span<int> source = stackalloc[] { 1, 2, 3 };
+        Func<int, bool>? nullPredicate = null;
+        var exception = new CustomException();
+
+        // Act & Assert
+        var result = Assert.Throws<ArgumentNullException>(() =>
+        {
+            Span<int> localSource = stackalloc[] { 1, 2, 3 };
+            ThrowIf.Any(localSource, nullPredicate!, exception);
+        });
+
+        Assert.Equal("predicate", result.ParamName);
+    }
+
+    [Fact]
+    public void Any_Span_ThrowsArgumentNullException_WhenExceptionIsNull()
+    {
+        // Arrange
+        Span<int> source = stackalloc[] { 1, 2, 3 };
+        Func<int, bool> predicate = x => x > 0;
+        CustomException? nullException = null;
+
+        // Act & Assert
+        var result = Assert.Throws<ArgumentNullException>(() =>
+        {
+            Span<int> localSource = stackalloc[] { 1, 2, 3 };
+            ThrowIf.Any(localSource, predicate, nullException!);
+        });
+
+        Assert.Equal("exception", result.ParamName);
+    }
+
+    [Fact]
+    public void Any_Span_ThrowsCustomException_WhenAnyElementSatisfiesPredicate()
+    {
+        // Arrange
+        Span<int> source = stackalloc[] { 1, 2, 3 };
+        Func<int, bool> predicate = x => x == 2;
+        var customException = new CustomException("Match found in Span");
+
+        // Act & Assert
+        var exception = Assert.Throws<CustomException>(() =>
+        {
+            Span<int> localSource = stackalloc[] { 1, 2, 3 };
+            ThrowIf.Any(localSource, predicate, customException);
+        });
+
+        Assert.Equal("Match found in Span", exception.Message);
+        Assert.Same(customException, exception);
+    }
+
+    [Fact]
+    public void Any_Span_DoesNotThrow_WhenNoElementSatisfiesPredicate()
+    {
+        // Arrange
+        Span<int> source = stackalloc[] { 1, 3, 5 };
+        Func<int, bool> predicate = x => x % 2 == 0;
+        var customException = new CustomException();
+
+        // Act & Assert - Should not throw
+        ThrowIf.Any(source, predicate, customException);
+    }
+
+    [Fact]
+    public void Any_Span_DoesNotThrow_WhenSourceIsEmpty()
+    {
+        // Arrange
+        Span<int> source = Span<int>.Empty;
+        Func<int, bool> predicate = x => true;
+        var customException = new CustomException();
+
+        // Act & Assert - Should not throw
+        ThrowIf.Any(source, predicate, customException);
+    }
+
+    [Fact]
+    public void Any_Span_InvokesCallback_WhenAnyElementSatisfiesPredicate()
+    {
+        // Arrange
+        Span<int> source = stackalloc[] { 1, 2, 3 };
+        Func<int, bool> predicate = x => x == 2;
+        var customException = new CustomException();
+        GuardOutcome? callbackOutcome = null;
+        SGuardCallback callback = outcome => callbackOutcome = outcome;
+
+        // Act & Assert
+        Assert.Throws<CustomException>(() =>
+        {
+            Span<int> localSource = stackalloc[] { 1, 2, 3 };
+            ThrowIf.Any(localSource, predicate, customException, callback);
+        });
+
+        Assert.Equal(GuardOutcome.Failure, callbackOutcome);
+    }
+
+    [Fact]
+    public void Any_Span_InvokesCallback_WhenNoElementSatisfiesPredicate()
+    {
+        // Arrange
+        Span<int> source = stackalloc[] { 1, 3, 5 };
+        Func<int, bool> predicate = x => x % 2 == 0;
+        var customException = new CustomException();
+        GuardOutcome? callbackOutcome = null;
+        SGuardCallback callback = outcome => callbackOutcome = outcome;
+
+        // Act
+        ThrowIf.Any(source, predicate, customException, callback);
+
+        // Assert
+        Assert.Equal(GuardOutcome.Success, callbackOutcome);
+    }
+
+    #endregion
+
     #region Performance and Short-Circuit Tests
 
     [Fact]