Reverted to simpler more robust hashing.

Author: electricessence

Source/EnumValue.cs

@@ -149,7 +149,6 @@ public void Deconstruct(out bool success, out TEnum value)
 			success = Success;
 			value = Value;
 		}
-
 	}
 
 	private static Func<string, ValueLookupResult>? _valueLookup;
@@ -195,7 +194,7 @@ public void Deconstruct(out string name, out TEnum value)
 			value = Value;
 		}
 
-		public static int Find(Span<Entry> span, StringSegment name, StringComparison sc)
+		public static int Find(Span<Entry> span, ReadOnlySpan<char> name, StringComparison sc)
 		{
 			// Small enough? Just brute force the index.
 			var len = span.Length;
@@ -218,12 +217,12 @@ public static int Find(Span<Entry> span, StringSegment name, StringComparison sc
 			while (left <= right)
 			{
 				int middle = left + (right - left) / 2;
-				var middleKey = span[middle].Name;
+				var middleKey = span[middle].Name.AsSpan();
 
 				if (right - left < 4 && name.Equals(middleKey, sc))
 					return middle;
 
-				var comparison = StringSegment.Compare(middleKey, name, sc);
+				var comparison = name.CompareTo(middleKey, sc);
 				if (comparison < 0)
 					left = middle + 1;
 				else if (comparison > 0)
@@ -539,14 +538,13 @@ public static bool TryParse<TEnum>(StringSegment value, out TEnum e)
 	public static bool TryParse<TEnum>(StringSegment name, bool ignoreCase, out TEnum e)
 		where TEnum : Enum
 	{
-		if (!name.HasValue) goto notFound;
+		var len = name.Length;
+		if (len == 0) goto notFound;
 
 		// If this is a string, use the optimized version.
-		if (!ignoreCase && name.Buffer.Length == name.Length)
+		if (!ignoreCase && name.Buffer!.Length == len)
 			return TryParse(name.Buffer, out e);
 
-		var len = name.Length;
-		if (len == 0) goto notFound;
 		var lookup = EnumValue<TEnum>.Lookup;
 		if (len >= lookup.Length) goto notFound;
 

Source/Extensions._.cs

@@ -435,33 +435,68 @@ public static string Supplant<T>(this string format, T[]? values, CultureInfo? c
 		};
 
 	/// <summary>
-	/// A hashing algorithm that is can be faster than the default string.GetHashCode()
-	/// but can be used for any sequence of characters reliably.
+	/// A hashing algorithm for a span of characters.
 	/// </summary>
 	/// <remarks>
 	/// Setting the <paramref name="maxChars"/> parameter to a low number
 	/// will dramatically increase the speed as more characters requires more iterations
 	/// at the expense of accuracy and possible collisions.
 	/// </remarks>
-	public static int GetHashCodeFromChars(this ReadOnlySpan<char> chars, int maxChars = int.MaxValue)
+	public static int GetHashCodeFromChars(this ReadOnlySpan<char> chars, StringComparison comparisonType = StringComparison.Ordinal, int maxChars = int.MaxValue)
 	{
 		int length = chars.Length > maxChars ? maxChars : chars.Length;
 
-		long hash = 0;
-		for (int i = 0; i < length; i++)
+		int hash = 17;
+		switch(comparisonType)
 		{
-			ref readonly char c = ref chars[i];
-			hash |= (long)c << (i * 8);
+			case StringComparison.Ordinal:
+			case StringComparison.CurrentCulture:
+			case StringComparison.InvariantCulture:
+			{
+				for (int i = 0; i < length; i++)
+				{
+					ref readonly char c = ref chars[i];
+					hash = (hash * 31) ^ c;
+				}
+
+				break;
+			}
+
+			case StringComparison.OrdinalIgnoreCase:
+			case StringComparison.CurrentCultureIgnoreCase:
+			{
+				for (int i = 0; i < length; i++)
+				{
+					ref readonly char c = ref chars[i];
+					hash = (hash * 31) ^ char.ToLower(c, CultureInfo.CurrentCulture);
+				}
+
+				break;
+			}
+
+			case StringComparison.InvariantCultureIgnoreCase:
+			{
+				for (int i = 0; i < length; i++)
+				{
+					ref readonly char c = ref chars[i];
+					hash = (hash * 31) ^ char.ToLowerInvariant(c);
+				}
+
+				break;
+			}
+
 		}
 
-		return (int)(hash ^ (hash >> 32));
+		return hash + length;
 	}
 
-	/// <inheritdoc cref="GetHashCodeFromChars(ReadOnlySpan{char}, int)"/>
-	public static int GetHashCodeFromChars(this StringSegment chars, int maxChars = int.MaxValue)
-		=> chars.AsSpan().GetHashCodeFromChars(maxChars);
+	/// <inheritdoc cref="GetHashCodeFromChars(ReadOnlySpan{char}, StringComparison, int)"/>
+	public static int GetHashCodeFromChars(this StringSegment chars, StringComparison comparisonType = StringComparison.Ordinal, int maxChars = int.MaxValue)
+		=> chars.HasValue
+		? chars.AsSpan().GetHashCodeFromChars(comparisonType, maxChars)
+		: throw new ArgumentNullException(nameof(chars), "The buffer must not be null.");
 
-	/// <inheritdoc cref="GetHashCodeFromChars(ReadOnlySpan{char}, int)"/>
-	public static int GetHashCodeFromChars(this string chars, int maxChars = int.MaxValue)
-		=> chars.AsSpan().GetHashCodeFromChars(maxChars);
+	/// <inheritdoc cref="GetHashCodeFromChars(ReadOnlySpan{char}, StringComparison, int)"/>
+	public static int GetHashCodeFromChars(this string chars, StringComparison comparisonType = StringComparison.Ordinal, int maxChars = int.MaxValue)
+		=> chars.AsSpan().GetHashCodeFromChars(comparisonType, maxChars);
 }

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.4</Version>
+		<Version>6.6.1</Version>
 		<PackageReleaseNotes></PackageReleaseNotes>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<PublishRepositoryUrl>true</PublishRepositoryUrl>

Source/StringSegmentComparer.cs

@@ -0,0 +1,86 @@
+using Microsoft.Extensions.Primitives;
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace Open.Text;
+
+/// <summary>
+/// A comparer for <see cref="StringSegment"/> that uses existing <see cref="StringSegment.Compare(StringSegment, StringSegment, StringComparison)"/>
+/// and <see cref="StringSegment.Equals(StringSegment, StringSegment, StringComparison)"/> for its comparisons
+/// and <see cref="TextExtensions.GetHashCodeFromChars(ReadOnlySpan{char}, StringComparison, int)"/> for hash codes.
+/// </summary>
+public class StringSegmentComparer
+	: IComparer<StringSegment>, IEqualityComparer<StringSegment>
+{
+	/// <summary>
+	/// A <see cref="StringSegmentComparer"/> that uses <see cref="StringComparison.Ordinal"/>.
+	/// </summary>
+	public static readonly StringSegmentComparer Ordinal = new();
+
+	/// <summary>
+	/// A <see cref="StringSegmentComparer"/> that uses <see cref="StringComparison.OrdinalIgnoreCase"/>.
+	/// </summary>
+	public static readonly StringSegmentComparer OrdinalIgnoreCase = new(StringComparison.OrdinalIgnoreCase);
+
+	/// <summary>
+	/// A <see cref="StringSegmentComparer"/> that uses <see cref="StringComparison.CurrentCulture"/>.
+	/// </summary>
+	public static readonly StringSegmentComparer CurrentCulture = new(StringComparison.CurrentCulture);
+
+	/// <summary>
+	/// A <see cref="StringSegmentComparer"/> that uses <see cref="StringComparison.CurrentCultureIgnoreCase"/>.
+	/// </summary>
+	public static readonly StringSegmentComparer CurrentCultureIgnoreCase = new(StringComparison.CurrentCultureIgnoreCase);
+
+	/// <summary>
+	/// A <see cref="StringSegmentComparer"/> that uses <see cref="StringComparison.InvariantCulture"/>.
+	/// </summary>
+	public static readonly StringSegmentComparer InvariantCulture = new(StringComparison.InvariantCulture);
+
+	/// <summary>
+	/// A <see cref="StringSegmentComparer"/> that uses <see cref="StringComparison.InvariantCultureIgnoreCase"/>.
+	/// </summary>
+	public static readonly StringSegmentComparer InvariantCultureIgnoreCase = new(StringComparison.InvariantCultureIgnoreCase);
+
+	/// <summary>
+	/// Creates a new instance of <see cref="StringSegmentComparer"/>
+	/// with the specified <paramref name="comparisonType"/>
+	/// and <paramref name="maxHashChars"/>.
+	/// </summary>
+	/// <param name="comparisonType">The string comparison type.</param>
+	/// <param name="maxHashChars">
+	/// The max number of characters to generate a hash from.
+	/// See <see cref="TextExtensions.GetHashCodeFromChars(ReadOnlySpan{char}, StringComparison, int)"/> for more details.
+	/// </param>
+	public StringSegmentComparer(StringComparison comparisonType = StringComparison.Ordinal, int maxHashChars = int.MaxValue)
+	{
+		ComparisonType = comparisonType;
+		MaxHashChars = maxHashChars;
+	}
+
+	/// <summary>
+	/// The string comparison type.
+	/// </summary>
+	public StringComparison ComparisonType { get; }
+
+	/// <summary>
+	/// The max number of characters to generate a hash from.
+	/// </summary>
+	public int MaxHashChars { get; }
+
+	/// <inheritdoc />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public int Compare(StringSegment x, StringSegment y)
+		=> StringSegment.Compare(x, y, ComparisonType);
+
+	/// <inheritdoc />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public bool Equals(StringSegment x, StringSegment y)
+		=> StringSegment.Equals(x, y, ComparisonType);
+
+	/// <inheritdoc />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public int GetHashCode(StringSegment obj)
+		=> obj.GetHashCodeFromChars(ComparisonType, MaxHashChars);
+}