Allow for null value comparison without throwing.

Author: electricessence

Source/StringComparable.cs

@@ -13,21 +13,17 @@ public readonly struct StringComparable
 	/// <summary>
 	/// Constructs a StringComparable using the provided string and comparison type.
 	/// </summary>
-	/// <exception cref="ArgumentException"><paramref name="segment"/> does not contain a value (is default).</exception>
 	public StringComparable(StringSegment segment, StringComparison type)
 	{
-		if (!segment.HasValue) throw new ArgumentException("The provided segment must have a value.", nameof(segment));
 		Segment = segment;
 		Type = type;
 	}
 
 	/// <summary>
 	/// Constructs a StringComparable using the provided string and comparison type.
 	/// </summary>
-	/// <exception cref="ArgumentNullException"><paramref name="value"/> is null</exception>
-	public StringComparable(string value, StringComparison type)
+	public StringComparable(string? value, StringComparison type)
 	{
-		if (value is null) throw new ArgumentNullException(nameof(value));
 		Segment = value;
 		Type = type;
 	}
@@ -52,7 +48,7 @@ public StringComparable(string value, StringComparison type)
 	/// </summary>
 	/// <returns>true if the value of <paramref name="other"/> matches; otherwise false. </returns>
 	public bool Equals(string? other)
-		=> other is not null && Segment.Equals(other, Type);
+		=> Segment.Equals(other, Type);
 
 	/// <inheritdoc cref="Equals(string?)"/>
 	public bool Equals(ReadOnlySpan<char> other)
@@ -174,41 +170,41 @@ public static class StringComparableExtensions
 	/// Prepares a string for a specific StringComparison operation.
 	/// </summary>
 	/// <inheritdoc cref="AsCaseInsensitive(string)"/>
-	public static StringComparable AsComparable(this string source, StringComparison type)
+	public static StringComparable AsComparable(this string? source, StringComparison type)
 		=> new(source, type);
 
 	/// <summary>
 	/// Prepares a string to be case insensitive when comparing equality.
 	/// </summary>
 	/// <returns>A StringComparable that can be compared (== or !=) against other StringComparables, SpanComparables, strings, and ReadOnlySpan&lt;char&gt;.</returns>
-	public static StringComparable AsCaseInsensitive(this string source)
+	public static StringComparable AsCaseInsensitive(this string? source)
 		=> new(source, StringComparison.OrdinalIgnoreCase);
 
 	/// <summary>
 	/// Prepares a string to be invariant culture and case insensitive when comparing equality.
 	/// </summary>
 	/// <inheritdoc cref="AsCaseInsensitive(string)"/>
-	public static StringComparable AsCaseInsensitiveInvariantCulture(this string source)
+	public static StringComparable AsCaseInsensitiveInvariantCulture(this string? source)
 		=> new(source, StringComparison.InvariantCultureIgnoreCase);
 
 	/// <summary>
 	/// Prepares a string to be invariant culture and case insensitive when comparing equality.
 	/// </summary>
 	/// <inheritdoc cref="AsCaseInsensitive(string)"/>
-	public static StringComparable AsCaseInsensitiveCurrentCulture(this string source)
+	public static StringComparable AsCaseInsensitiveCurrentCulture(this string? source)
 		=> new(source, StringComparison.CurrentCultureIgnoreCase);
 
 	/// <summary>
 	/// Prepares a string to be current culture and case sensitive when comparing equality.
 	/// </summary>
 	/// <inheritdoc cref="AsCaseInsensitive(string)"/>
-	public static StringComparable AsCurrentCulture(this string source)
+	public static StringComparable AsCurrentCulture(this string? source)
 		=> new(source, StringComparison.CurrentCulture);
 
 	/// <summary>
 	/// Prepares a string to be invariant culture and case sensitive when comparing equality.
 	/// </summary>
-	public static StringComparable AsInvariantCulture(this string source)
+	public static StringComparable AsInvariantCulture(this string? source)
 		=> new(source, StringComparison.InvariantCulture);
 
 	/// <summary>

Tests/ComparableTests.cs

@@ -6,9 +6,10 @@ namespace Open.Text.Tests;
 public static class ComparableTests
 {
 	[Theory]
+	[InlineData(null, null)]
 	[InlineData("ABC", "abc")]
 	[InlineData("XyZ", "xYz")]
-	public static void CaseInsensitive(string a, string b)
+	public static void CaseInsensitive(string? a, string? b)
 	{
 		var cA = a.AsCaseInsensitive();
 		var cB = b.AsCaseInsensitive();
@@ -23,6 +24,8 @@ public static void CaseInsensitive(string a, string b)
 		var sB = b.AsSpan().AsCaseInsensitive();
 
 		Assert.True(sA == sB);
+		if (a is null || b is null) return;
+
 		Assert.True(sA == a);
 		Assert.True(sB == b);
 		Assert.True(sB == a);
@@ -76,4 +79,29 @@ public static void CaseSensitive(string a, string b)
 		Assert.False(sB == cA);
 		Assert.True(sB == cB);
 	}
+
+	[Fact]
+	public static void NullTests()
+	{
+		var cA = "ABC".AsCaseInsensitive();
+		var cB = default(string).AsCaseInsensitive();
+		Assert.False(cA == cB);
+		Assert.True(cA != cB);
+		Assert.False(cB == cA);
+		Assert.True(cB != cA);
+
+		cA = "".AsCaseInsensitive();
+		cB = default(string).AsCaseInsensitive();
+		Assert.False(cA == cB);
+		Assert.True(cA != cB);
+		Assert.False(cB == cA);
+		Assert.True(cB != cA);
+
+		cA = default(string).AsCaseInsensitive();
+		cB = default(string).AsCaseInsensitive();
+		Assert.True(cA == cB);
+		Assert.False(cA != cB);
+		Assert.True(cB == cA);
+		Assert.False(cB != cA);
+	}
 }