Cleanup with added comparison operators and improved docs.

Author: electricessence

Benchmarks/EnumAttributeTests.cs

@@ -1,5 +1,4 @@
 using BenchmarkDotNet.Attributes;
-using System.Linq.Expressions;
 
 namespace Open.Text.Benchmarks;
 

Benchmarks/EnumToStringTests.cs

@@ -1,8 +1,5 @@
 using BenchmarkDotNet.Attributes;
-using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
 
 namespace Open.Text.Benchmarks;
 
@@ -54,6 +51,6 @@ public void EnumValueGetName()
 	public void GetCachedName()
 	{
 		foreach (var g in Values)
-			_ = _reg.GetOrAdd(g, k=>k.ToString());
+			_ = _reg.GetOrAdd(g, k => k.ToString());
 	}
 }

Benchmarks/Greek.cs

@@ -1,9 +1,8 @@
-using System;
-
-namespace Open.Text.Benchmarks;
+namespace Open.Text.Benchmarks;
 
 [AttributeUsage(AttributeTargets.Field)]
-public class LetterAttribute : Attribute {
+public class LetterAttribute : Attribute
+{
 	public LetterAttribute(char upper, char lower)
 	{
 		Upper = upper;
@@ -19,25 +18,25 @@ public bool EqualsLetter(char letter)
 
 public enum Greek
 {
-	[Letter('Α','α')]
+	[Letter('Α', 'α')]
 	Alpha,
 	[Letter('Β', 'β')]
 	Beta,
 	[Letter('b', 'b')]
 	Beta2,
-	[Letter('Κ','κ')]
+	[Letter('Κ', 'κ')]
 	Kappa,
-	[Letter('Δ','δ')]
+	[Letter('Δ', 'δ')]
 	Delta,
-	[Letter('Ε','ε')]
+	[Letter('Ε', 'ε')]
 	Epsilon,
-	[Letter('Γ','γ')]
+	[Letter('Γ', 'γ')]
 	Gamma,
-	[Letter('Ω','ω')]
+	[Letter('Ω', 'ω')]
 	Omega,
-	[Letter('Φ','φ')]
+	[Letter('Φ', 'φ')]
 	Phi,
-	[Letter('Θ','θ')]
+	[Letter('Θ', 'θ')]
 	Theta,
 	None
 }

Source/EnumValue.cs

@@ -6,9 +6,9 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Linq.Expressions;
-using static System.Linq.Expressions.Expression;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using static System.Linq.Expressions.Expression;
 
 namespace Open.Text;
 

Source/Extensions.Split.cs

@@ -59,7 +59,7 @@ static ReadOnlyMemory<char> FirstSplitMemory(string source, int start, int i, in
 	/// Finds the first instance of a character and returns the set of characters up to that character.
 	/// </summary>
 	/// <param name="source">The source characters to look through.</param>
-	/// <param name="splitCharacter">The charcter to find.</param>
+	/// <param name="splitCharacter">The character to find.</param>
 	/// <param name="nextIndex">The next possible index following the current one.</param>
 	/// <param name="startIndex">The index to start the split.</param>
 	/// <returns>The portion of the source up to and excluding the sequence searched for.</returns>
@@ -170,7 +170,7 @@ public static ReadOnlySpan<char> FirstSplit(this ReadOnlySpan<char> source,
 	/// Enumerates a string by segments that are separated by the split character.
 	/// </summary>
 	/// <param name="source">The source characters to look through.</param>
-	/// <param name="splitCharacter">The charcter to find.</param>
+	/// <param name="splitCharacter">The character to find.</param>
 	/// <param name="options">Can specify to omit empty entries.</param>
 	/// <returns>An enumerable of the segments.</returns>
 	public static IEnumerable<string> SplitToEnumerable(this string source,
@@ -387,29 +387,29 @@ public static IReadOnlyList<string> Split(this ReadOnlySpan<char> source,
 				return Array.Empty<string>();
 
 			case StringSplitOptions.RemoveEmptyEntries:
-				{
-					Debug.Assert(!source.IsEmpty);
-					var list = new List<string>();
-
-				loop:
-					var result = source.FirstSplit(splitCharacter, out var nextIndex);
-					if (!result.IsEmpty) list.Add(result.ToString());
-					if (nextIndex == -1) return list;
-					source = source.Slice(nextIndex);
-					goto loop;
-				}
+			{
+				Debug.Assert(!source.IsEmpty);
+				var list = new List<string>();
+
+			loop:
+				var result = source.FirstSplit(splitCharacter, out var nextIndex);
+				if (!result.IsEmpty) list.Add(result.ToString());
+				if (nextIndex == -1) return list;
+				source = source.Slice(nextIndex);
+				goto loop;
+			}
 
 			default:
-				{
-					Debug.Assert(!source.IsEmpty);
-					var list = new List<string>();
-				loop:
-					var result = source.FirstSplit(splitCharacter, out var nextIndex);
-					list.Add(result.IsEmpty ? string.Empty : result.ToString());
-					if (nextIndex == -1) return list;
-					source = source.Slice(nextIndex);
-					goto loop;
-				}
+			{
+				Debug.Assert(!source.IsEmpty);
+				var list = new List<string>();
+			loop:
+				var result = source.FirstSplit(splitCharacter, out var nextIndex);
+				list.Add(result.IsEmpty ? string.Empty : result.ToString());
+				if (nextIndex == -1) return list;
+				source = source.Slice(nextIndex);
+				goto loop;
+			}
 		}
 	}
 
@@ -419,7 +419,7 @@ public static IReadOnlyList<string> Split(this ReadOnlySpan<char> source,
 	/// <param name="source">The source string to split up.</param>
 	/// <param name="splitSequence">The sequence to split by.</param>
 	/// <param name="options">Can specify to omit empty entries.</param>
-	/// <param name="comparisonType">The optional comparsion type.</param>
+	/// <param name="comparisonType">The optional comparison type.</param>
 	/// <returns>The resultant list of string segments.</returns>
 	public static IReadOnlyList<string> Split(this ReadOnlySpan<char> source,
 		ReadOnlySpan<char> splitSequence,
@@ -435,29 +435,29 @@ public static IReadOnlyList<string> Split(this ReadOnlySpan<char> source,
 				return Array.Empty<string>();
 
 			case StringSplitOptions.RemoveEmptyEntries:
-				{
-					Debug.Assert(!source.IsEmpty);
-					var list = new List<string>();
-
-				loop:
-					var result = source.FirstSplit(splitSequence, out var nextIndex, comparisonType);
-					if (!result.IsEmpty) list.Add(result.ToString());
-					if (nextIndex == -1) return list;
-					source = source.Slice(nextIndex);
-					goto loop;
-				}
+			{
+				Debug.Assert(!source.IsEmpty);
+				var list = new List<string>();
+
+			loop:
+				var result = source.FirstSplit(splitSequence, out var nextIndex, comparisonType);
+				if (!result.IsEmpty) list.Add(result.ToString());
+				if (nextIndex == -1) return list;
+				source = source.Slice(nextIndex);
+				goto loop;
+			}
 
 			default:
-				{
-					Debug.Assert(!source.IsEmpty);
-					var list = new List<string>();
-				loop:
-					var result = source.FirstSplit(splitSequence, out var nextIndex, comparisonType);
-					list.Add(result.IsEmpty ? string.Empty : result.ToString());
-					if (nextIndex == -1) return list;
-					source = source.Slice(nextIndex);
-					goto loop;
-				}
+			{
+				Debug.Assert(!source.IsEmpty);
+				var list = new List<string>();
+			loop:
+				var result = source.FirstSplit(splitSequence, out var nextIndex, comparisonType);
+				list.Add(result.IsEmpty ? string.Empty : result.ToString());
+				if (nextIndex == -1) return list;
+				source = source.Slice(nextIndex);
+				goto loop;
+			}
 		}
 	}
 }

Source/Extensions.StringSegment.cs

@@ -391,7 +391,7 @@ public static IEnumerable<StringSegment> SplitAsSegments(
 			? throw new ArgumentNullException(nameof(source))
 			: pattern is null
 			? throw new ArgumentNullException(nameof(pattern))
-			: source.Length==0
+			: source.Length == 0
 			? options == StringSplitOptions.RemoveEmptyEntries
 				? Enumerable.Empty<StringSegment>()
 				: Enumerable.Repeat(StringSegment.Empty, 1)

Source/Extensions._.cs

@@ -405,7 +405,7 @@ public static string ReplaceWhiteSpace(this string source, string replace = " ")
 	public const string Newline = "\r\n";
 
 	/// <summary>
-	/// Shortcut for WriteLineNoTabs on a TextWriter. Mimimcs similar classes.
+	/// Shortcut for WriteLineNoTabs on a TextWriter. Mimics similar classes.
 	/// </summary>
 	[ExcludeFromCodeCoverage]
 	public static void WriteLineNoTabs(this TextWriter writer, string? s = null)

Source/Open.Text.csproj

@@ -19,7 +19,7 @@
 		<RepositoryUrl>https://github.com/Open-NET-Libraries/Open.Text</RepositoryUrl>
 		<RepositoryType>git</RepositoryType>
 		<PackageTags>string, span, enum, readonlyspan, text, format, split, trim, equals, trimmed equals, first, last, preceding, following, stringbuilder, extensions, stringcomparable, spancomparable, stringsegment, splitassegment</PackageTags>
-		<Version>6.5.1</Version>
+		<Version>6.5.2</Version>
 		<PackageReleaseNotes></PackageReleaseNotes>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<PublishRepositoryUrl>true</PublishRepositoryUrl>

Source/SpanComparable.cs

@@ -6,12 +6,12 @@
 namespace Open.Text;
 
 /// <summary>
-/// A StringComparison variable struct for comparing a ReadOnlySpan&lt;char&gt; against other values.
+/// A <see cref="StringComparison"/> struct for comparing a span against other values.
 /// </summary>
 public readonly ref struct SpanComparable
 {
 	/// <summary>
-	/// Constructs a SpanComparable using the provided string and comparison type.
+	/// Constructs a <see cref="SpanComparable"/> using the provided string and comparison type.
 	/// </summary>
 	public SpanComparable(ReadOnlySpan<char> source, StringComparison type)
 	{
@@ -100,62 +100,92 @@ public override int GetHashCode()
 #pragma warning restore IDE0079 // Remove unnecessary suppression
 
 	/// <summary>
-	/// Compares two SpanComparables for equality.
+	/// Compares two <see cref="SpanComparable"/>s for equality.
 	/// </summary>
 	public static bool operator ==(SpanComparable a, SpanComparable b) => a.Equals(b);
 
 	/// <summary>
-	/// Compares two SpanComparables for inequality.
+	/// Compares two <see cref="SpanComparable"/>s for inequality.
 	/// </summary>
 	public static bool operator !=(SpanComparable a, SpanComparable b) => !a.Equals(b);
 
 	/// <summary>
-	/// Compares a SpanComparable with a string for equality.
+	/// Compares a <see cref="SpanComparable"/> and a <see cref="StringSegment"/> for equality.
 	/// </summary>
-	public static bool operator ==(SpanComparable a, string? b) => a.Equals(b);
+	public static bool operator ==(SpanComparable comparable, StringSegment segment) => comparable.Equals(segment);
 
 	/// <summary>
-	/// Compares a SpanComparable with a StringSegment for inequality.
+	/// Compares a <see cref="SpanComparable"/> and a <see cref="StringSegment"/> for inequality.
 	/// </summary>
-	public static bool operator !=(SpanComparable a, StringSegment b) => !a.Equals(b);
+	public static bool operator !=(SpanComparable comparable, StringSegment segment) => !comparable.Equals(segment);
 
 	/// <summary>
-	/// Compares a SpanComparable with a StringSegment for equality.
+	/// Compares a <see cref="StringSegment"/> and a <see cref="SpanComparable"/> for equality.
 	/// </summary>
-	public static bool operator ==(SpanComparable a, StringSegment b) => a.Equals(b);
+	public static bool operator ==(StringSegment segment, SpanComparable comparable) => comparable.Equals(segment);
 
 	/// <summary>
-	/// Compares a SpanComparable with a string for inequality.
+	/// Compares a <see cref="StringSegment"/> and a <see cref="SpanComparable"/> for inequality.
 	/// </summary>
-	public static bool operator !=(SpanComparable a, string? b) => !a.Equals(b);
+	public static bool operator !=(StringSegment segment, SpanComparable comparable) => !comparable.Equals(segment);
 
 	/// <summary>
-	/// Compares a SpanComparable with a span for equality.
+	/// Compares a <see cref="SpanComparable"/> and a <see cref="string"/> for equality.
 	/// </summary>
-	public static bool operator ==(SpanComparable a, ReadOnlySpan<char> b) => a.Equals(b);
+	public static bool operator ==(SpanComparable comparable, string? str) => comparable.Equals(str);
 
 	/// <summary>
-	/// Compares a SpanComparable with a span for inequality.
+	/// Compares a <see cref="SpanComparable"/> and a <see cref="string"/> for inequality.
 	/// </summary>
-	public static bool operator !=(SpanComparable a, ReadOnlySpan<char> b) => !a.Equals(b);
+	public static bool operator !=(SpanComparable comparable, string? str) => !comparable.Equals(str);
 
 	/// <summary>
-	/// Compares a SpanComparable with a StringComparable for equality.
+	/// Compares a <see cref="string"/> and a <see cref="SpanComparable"/> for equality.
 	/// </summary>
-	public static bool operator ==(SpanComparable a, StringComparable b) => a.Equals(b);
+	public static bool operator ==(string? str, SpanComparable comparable) => comparable.Equals(str);
 
 	/// <summary>
-	/// Compares a SpanComparable with a StringComparable for inequality.
+	/// Compares a <see cref="string"/> and a <see cref="SpanComparable"/> for inequality.
 	/// </summary>
-	public static bool operator !=(SpanComparable a, StringComparable b) => !a.Equals(b);
+	public static bool operator !=(string? str, SpanComparable comparable) => !comparable.Equals(str);
+
+	/// <summary>
+	/// Compares a <see cref="SpanComparable"/> with a span for equality.
+	/// </summary>
+	public static bool operator ==(SpanComparable comparable, ReadOnlySpan<char> segment) => comparable.Equals(segment);
+
+	/// <summary>
+	/// Compares a <see cref="SpanComparable"/> with a span for inequality.
+	/// </summary>
+	public static bool operator !=(SpanComparable comparable, ReadOnlySpan<char> segment) => !comparable.Equals(segment);
+
+	/// <summary>
+	/// Compares a span with a <see cref="SpanComparable"/> for equality.
+	/// </summary>
+	public static bool operator ==(ReadOnlySpan<char> segment, SpanComparable comparable) => comparable.Equals(segment);
+
+	/// <summary>
+	/// Compares a span with a <see cref="SpanComparable"/> for inequality.
+	/// </summary>
+	public static bool operator !=(ReadOnlySpan<char> segment, SpanComparable comparable) => !comparable.Equals(segment);
+
+	/// <summary>
+	/// Compares a <see cref="SpanComparable"/> with a <see cref="StringComparable"/> for equality.
+	/// </summary>
+	public static bool operator ==(SpanComparable span, StringComparable str) => span.Equals(str);
+
+	/// <summary>
+	/// Compares a <see cref="SpanComparable"/> with a <see cref="StringComparable"/> for inequality.
+	/// </summary>
+	public static bool operator !=(SpanComparable span, StringComparable str) => !span.Equals(str);
 }
 
-/// <summary>Extensions for SpanComparable.</summary>
+/// <summary>Extensions for <see cref="SpanComparable"/>.</summary>
 [ExcludeFromCodeCoverage]
 public static class SpanComparableExtensions
 {
 	/// <summary>
-	/// Prepares a span for a specific StringComparison operation.
+	/// Prepares a span for a specific <see cref="StringComparison"/> operation.
 	/// </summary>
 	/// <inheritdoc cref="AsCaseInsensitive(ReadOnlySpan{char})"/>
 	public static SpanComparable AsComparable(this ReadOnlySpan<char> source, StringComparison type)
@@ -195,11 +225,4 @@ public static SpanComparable AsCurrentCulture(this ReadOnlySpan<char> source)
 	/// <inheritdoc cref="AsCaseInsensitive(ReadOnlySpan{char})"/>
 	public static SpanComparable AsInvariantCulture(this ReadOnlySpan<char> source)
 		=> new(source, StringComparison.InvariantCulture);
-
-	/// <summary>
-	/// Prepares a StringSegment for a specific StringComparison operation.
-	/// </summary>
-	/// <inheritdoc cref="AsCaseInsensitive(ReadOnlySpan{char})"/>
-	public static SpanComparable AsComparable(this StringSegment source, StringComparison type)
-		=> new(source, type);
 }

Source/StringBuilderExtensions.cs

@@ -494,7 +494,6 @@ public static StringBuilder TrimStart(this StringBuilder sb)
 		return sb;
 	}
 
-
 	/// <summary>
 	/// Trims the specified characters from the beginning of the <see cref="StringBuilder"/>.
 	/// </summary>
@@ -521,7 +520,6 @@ public static StringBuilder TrimStart(this StringBuilder sb, ReadOnlySpan<char>
 	public static StringBuilder Trim(this StringBuilder sb)
 		=> TrimEnd(sb).TrimStart();
 
-
 	/// <summary>
 	/// Trims the specified characters from the beginning and end of the <see cref="StringBuilder"/>.
 	/// </summary>