added Ensure extensions generator

Railway.SourceGenerator/EnsureExtensionExecutor.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen;
+
+public sealed class EnsureExtensionExecutor : IGeneratorExecutor
+{
+    public void Execute(SourceProductionContext context, Compilation source)
+    {
+        var methods = GenerateMethods();
+        var code = $$"""
+        #nullable enable
+        using System;
+        using System.Linq;
+        using System.Collections.Generic;
+        using System.Diagnostics.Contracts;
+        using System.CodeDom.Compiler;
+
+        namespace Just.Railway;
+
+        public static partial class Ensure
+        {
+        {{methods}}
+        }
+        """;
+
+        context.AddSource("Ensure.Extensions.g.cs", code);
+    }
+
+    private string GenerateMethods()
+    {
+        List<(string ErrorParameterDecl, string ErrorValueExpr)> errorGenerationDefinitions =
+        [
+            ("Error error = default!", "error"),
+            ("ErrorFactory errorFactory", "errorFactory(ensure.ValueExpression)")
+        ];
+
+        var sb = new StringBuilder();
+
+        sb.AppendLine($"#region Satisfies");
+        errorGenerationDefinitions.ForEach(def => GenerateSatisfiesExtensions(sb, def.ErrorParameterDecl, def.ErrorValueExpr));
+        sb.AppendLine("#endregion");
+
+        sb.AppendLine($"#region NotNull");
+        errorGenerationDefinitions.ForEach(def => GenerateNotNullExtensions(sb, def.ErrorParameterDecl, def.ErrorValueExpr));
+        sb.AppendLine("#endregion");
+
+        sb.AppendLine($"#region NotEmpty");
+        errorGenerationDefinitions.ForEach(def => GenerateNotEmptyExtensions(sb, def.ErrorParameterDecl, def.ErrorValueExpr));
+        sb.AppendLine("#endregion");
+
+
+        return sb.ToString();
+    }
+
+    private void GenerateNotEmptyExtensions(StringBuilder sb, string errorParameterDecl, string errorValueExpr)
+    {
+        string defaultErrorExpr = "?? Error.New(DefaultErrorType, $\"Value {{{ensure.ValueExpression}}} is empty.\")";
+        List<(string TemplateDef, string CollectionType, string NotEmptyTest)> typeOverloads =
+        [
+            ("<T>", "IEnumerable<T>", "ensure.Value?.Any() == true"),
+            ("<T>", "ICollection<T>", "ensure.Value?.Count > 0"),
+            ("<T>", "IReadOnlyCollection<T>", "ensure.Value?.Count > 0"),
+            ("<T>", "IList<T>", "ensure.Value?.Count > 0"),
+            ("<T>", "IReadOnlyList<T>", "ensure.Value?.Count > 0"),
+            ("<T>", "ISet<T>", "ensure.Value?.Count > 0"),
+            ("<T>", "IReadOnlySet<T>", "ensure.Value?.Count > 0"),
+            ("<TKey,TValue>", "IDictionary<TKey,TValue>", "ensure.Value?.Count > 0"),
+            ("<TKey,TValue>", "IReadOnlyDictionary<TKey,TValue>", "ensure.Value?.Count > 0"),
+            ("<T>", "T[]", "ensure.Value?.Length > 0"),
+            ("<T>", "List<T>", "ensure.Value?.Count > 0"),
+            ("<T>", "Queue<T>", "ensure.Value?.Count > 0"),
+            ("<T>", "HashSet<T>", "ensure.Value?.Count > 0"),
+            ("", "string", "!string.IsNullOrEmpty(ensure.Value)"),
+        ];
+
+        typeOverloads.ForEach(def => sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(EnsureExtensionExecutor)}}", "1.0.0.0")]
+        public static Ensure<{{def.CollectionType}}> NotEmpty{{def.TemplateDef}}(this in Ensure<{{def.CollectionType}}> ensure, {{errorParameterDecl}})
+        {
+            return ensure.State switch
+            {
+                ResultState.Success => {{def.NotEmptyTest}}
+                    ? new(ensure.Value, ensure.ValueExpression)
+                    : new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression),
+                ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+                _ => throw new EnsureNotInitializedException(nameof(ensure))
+            };
+        }
+        """));
+    }
+
+    private void GenerateNotNullExtensions(StringBuilder sb, string errorParameterDecl, string errorValueExpr)
+    {
+        string defaultErrorExpr = "?? Error.New(DefaultErrorType, $\"Value {{{ensure.ValueExpression}}} is null.\")";
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(EnsureExtensionExecutor)}}", "1.0.0.0")]
+        public static Ensure<T> NotNull<T>(this in Ensure<T?> ensure, {{errorParameterDecl}})
+            where T : struct
+        {
+            return ensure.State switch
+            {
+                ResultState.Success => ensure.Value.HasValue
+                    ? new(ensure.Value.Value, ensure.ValueExpression)
+                    : new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression),
+                ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+                _ => throw new EnsureNotInitializedException(nameof(ensure))
+            };
+        }
+        """);
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(EnsureExtensionExecutor)}}", "1.0.0.0")]
+        public static Ensure<T> NotNull<T>(this in Ensure<T?> ensure, {{errorParameterDecl}})
+            where T : notnull
+        {
+            return ensure.State switch
+            {
+                ResultState.Success => ensure.Value is not null
+                    ? new(ensure.Value!, ensure.ValueExpression)
+                    : new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression),
+                ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+                _ => throw new EnsureNotInitializedException(nameof(ensure))
+            };
+        }
+        """);
+    }
+
+    private void GenerateSatisfiesExtensions(StringBuilder sb, string errorParameterDecl, string errorValueExpr)
+    {
+        string defaultErrorExpr = "?? Error.New(DefaultErrorType, $\"Value {{{ensure.ValueExpression}}} does not satisfy the requirement.\")";
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(EnsureExtensionExecutor)}}", "1.0.0.0")]
+        public static Ensure<T> Satisfies<T>(this in Ensure<T> ensure, Func<T, bool> requirement, {{errorParameterDecl}})
+        {
+            return ensure.State switch
+            {
+                ResultState.Success => requirement(ensure.Value)
+                    ? new(ensure.Value, ensure.ValueExpression)
+                    : new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression),
+                ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+                _ => throw new EnsureNotInitializedException(nameof(ensure))
+            };
+        }
+        """);
+
+        GenerateSatisfiesAsyncExtensions(sb, "Task", errorParameterDecl, errorValueExpr, defaultErrorExpr);
+        GenerateSatisfiesAsyncExtensions(sb, "ValueTask", errorParameterDecl, errorValueExpr, defaultErrorExpr);
+    }
+
+    private void GenerateSatisfiesAsyncExtensions(StringBuilder sb, string taskType, string errorParameterDecl, string errorValueExpr, string defaultErrorExpr)
+    {
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(EnsureExtensionExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<Ensure<T>> Satisfies<T>(this {{taskType}}<Ensure<T>> ensureTask, Func<T, bool> requirement, {{errorParameterDecl}})
+        {
+            var ensure = await ensureTask.ConfigureAwait(false);
+            return ensure.State switch
+            {
+                ResultState.Success => requirement(ensure.Value)
+                    ? new(ensure.Value, ensure.ValueExpression)
+                    : new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression),
+                ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+                _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+            };
+        }
+        """);
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(EnsureExtensionExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<Ensure<T>> Satisfies<T>(this Ensure<T> ensure, Func<T, {{taskType}}<bool>> requirement, {{errorParameterDecl}})
+        {
+            return ensure.State switch
+            {
+                ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
+                    ? new(ensure.Value, ensure.ValueExpression)
+                    : new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression),
+                ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+                _ => throw new EnsureNotInitializedException(nameof(ensure))
+            };
+        }
+        """);
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(EnsureExtensionExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<Ensure<T>> Satisfies<T>(this {{taskType}}<Ensure<T>> ensureTask, Func<T, {{taskType}}<bool>> requirement, {{errorParameterDecl}})
+        {
+            var ensure = await ensureTask.ConfigureAwait(false);
+            return ensure.State switch
+            {
+                ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
+                    ? new(ensure.Value, ensure.ValueExpression)
+                    : new({{errorValueExpr}} {{defaultErrorExpr}}, ensure.ValueExpression),
+                ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+                _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+            };
+        }
+        """);
+    }
+}

Railway.SourceGenerator/ExtensionsMethodGenerator.cs

@@ -19,6 +19,7 @@ public class ExtensionsMethodGenerator : IIncrementalGenerator
         new ResultTapExecutor(),
         new ResultAppendExecutor(),
         new TryExtensionsExecutor(),
+        new EnsureExtensionExecutor(),
     };
 
     public void Initialize(IncrementalGeneratorInitializationContext context)

Railway/Ensure.cs

@@ -1,13 +1,12 @@
 namespace Just.Railway;
 
-public static class Ensure
+public static partial class Ensure
 {
     public delegate Error ErrorFactory(string valueExpression);
 
     public const string DefaultErrorType = "EnsureFailed";
 
     [Pure] public static Ensure<T> That<T>(T value, [CallerArgumentExpression(nameof(value))]string valueExpression = "") => new(value, valueExpression);
-    [Pure] public static async Task<Ensure<T>> That<T>(Task<T> value, [CallerArgumentExpression(nameof(value))]string valueExpression = "") => new(await value.ConfigureAwait(false), valueExpression);
 
     [Pure] public static Result<T> Result<T>(this in Ensure<T> ensure) => ensure.State switch
     {
@@ -15,8 +14,7 @@ public static class Ensure
         ResultState.Error => new(ensure.Error!),
         _ => throw new EnsureNotInitializedException(nameof(ensure))
     };
-    [Pure]
+    [Pure] public static async Task<Result<T>> Result<T>(this Task<Ensure<T>> ensureTask)
-    public static async Task<Result<T>> Result<T>(this Task<Ensure<T>> ensureTask)
     {
         var ensure = await ensureTask.ConfigureAwait(false);
         return ensure.State switch
@@ -26,261 +24,18 @@ public static class Ensure
             _ => throw new EnsureNotInitializedException(nameof(ensureTask))
         };
     }
-    [Pure]
+    [Pure] public static async ValueTask<Result<T>> Result<T>(this ValueTask<Ensure<T>> ensureTask)
-    public static Ensure<T> Satisfies<T>(this in Ensure<T> ensure, Func<T, bool> requirement, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => requirement(ensure.Value)
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<T> Satisfies<T>(this in Ensure<T> ensure, Func<T, bool> requirement, ErrorFactory errorFactory)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => requirement(ensure.Value)
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, bool> requirement, Error error = default!)
     {
         var ensure = await ensureTask.ConfigureAwait(false);
         return ensure.State switch
         {
-            ResultState.Success => requirement(ensure.Value)
+            ResultState.Success => new(ensure.Value),
-                ? new(ensure.Value, ensure.ValueExpression)
+            ResultState.Error => new(ensure.Error!),
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, bool> requirement, ErrorFactory errorFactory)
-    {
-        var ensure = await ensureTask.ConfigureAwait(false);
-        return ensure.State switch
-        {
-            ResultState.Success => requirement(ensure.Value)
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> Satisfies<T>(this Ensure<T> ensure, Func<T, Task<bool>> requirement, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> Satisfies<T>(this Ensure<T> ensure, Func<T, Task<bool>> requirement, ErrorFactory errorFactory)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, Task<bool>> requirement, Error error = default!)
-    {
-        var ensure = await ensureTask.ConfigureAwait(false);
-        return ensure.State switch
-        {
-            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, Task<bool>> requirement, ErrorFactory errorFactory)
-    {
-        var ensure = await ensureTask.ConfigureAwait(false);
-        return ensure.State switch
-        {
-            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
             _ => throw new EnsureNotInitializedException(nameof(ensureTask))
         };
     }
 
-    [Pure]
+    [Pure] public static Ensure<string> NotWhitespace(this in Ensure<string> ensure, Error error = default!)
-    public static Ensure<T> NotNull<T>(this in Ensure<T?> ensure, Error error = default!)
-        where T : struct
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value.HasValue
-                ? new(ensure.Value.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> NotNull<T>(this Task<Ensure<T?>> ensureTask, Error error = default!)
-        where T : struct
-    {
-        var ensure = await ensureTask.ConfigureAwait(false);
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value.HasValue
-                ? new(ensure.Value.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
-        };
-    }
-    [Pure]
-    public static Ensure<T> NotNull<T>(this in Ensure<T?> ensure, Error error = default!)
-        where T : notnull
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static async Task<Ensure<T>> NotNull<T>(this Task<Ensure<T?>> ensureTask, Error error = default!)
-        where T : notnull
-    {
-        var ensure = await ensureTask.ConfigureAwait(false);
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
-        };
-    }
-
-    [Pure]
-    public static Ensure<T[]> NotEmpty<T>(this in Ensure<T[]> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null && ensure.Value.Length > 0
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<List<T>> NotEmpty<T>(this in Ensure<List<T>> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<IReadOnlyCollection<T>> NotEmpty<T>(this in Ensure<IReadOnlyCollection<T>> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<ICollection<T>> NotEmpty<T>(this in Ensure<ICollection<T>> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<IReadOnlyList<T>> NotEmpty<T>(this in Ensure<IReadOnlyList<T>> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<IList<T>> NotEmpty<T>(this in Ensure<IList<T>> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<IEnumerable<T>> NotEmpty<T>(this in Ensure<IEnumerable<T>> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => ensure.Value is not null && ensure.Value.Any()
-                ? new(ensure.Value, ensure.ValueExpression)
-                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-    [Pure]
-    public static Ensure<string> NotEmpty(this in Ensure<string> ensure, Error error = default!)
-    {
-        return ensure.State switch
-        {
-            ResultState.Success => string.IsNullOrEmpty(ensure.Value)
-                ? new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression)
-                : new(ensure.Value, ensure.ValueExpression),
-            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
-            _ => throw new EnsureNotInitializedException(nameof(ensure))
-        };
-    }
-
-    [Pure]
-    public static Ensure<string> NotWhitespace(this in Ensure<string> ensure, Error error = default!)
     {
         return ensure.State switch
         {