Add new string extension methods and optimize usings

Introduced new extension methods for ReadOnlySpan<char>, StringSegment, and string to enhance string operations with various comparison options. Added global using directives for commonly used namespaces to simplify code. Removed redundant using directives and updated project version to 7.1.0.

Author: electricessence

Benchmarks/EnumParseTests.cs

@@ -1,6 +1,5 @@
 using BenchmarkDotNet.Attributes;
 using FastEnumUtility;
-using System.Security;
 
 namespace Open.Text.Benchmarks;
 

Source/EnumValue.cs

@@ -1,15 +1,6 @@
-// Ignore Spelling: Deconstruct
-
-using Microsoft.Extensions.Primitives;
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Concurrent;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Linq.Expressions;
-using System.Runtime.CompilerServices;
-using System.Threading;
 using static System.Linq.Expressions.Expression;
 //using static FastExpressionCompiler.LightExpression.Expression;
 namespace Open.Text;

Source/Extensions.Equals.cs

@@ -1,7 +1,4 @@
-using Microsoft.Extensions.Primitives;
-using System;
-
-namespace Open.Text;
+namespace Open.Text;
 
 public static partial class TextExtensions
 {

Source/Extensions.FirstLast.cs

@@ -0,0 +1,137 @@
+namespace Open.Text;
+public static partial class TextExtensions
+{
+	/// <summary>
+	/// Finds the first instance of a string and returns a StringSegment for subsequent use.
+	/// </summary>
+	/// <param name="source">The source string to search.</param>
+	/// <param name="search">The string pattern to look for.</param>
+	/// <param name="comparisonType">The string comparison type to use.  Default is Ordinal.</param>
+	/// <returns>
+	/// The segment representing the found string.
+	/// If not found, the result will have a length of 0 and its <see cref="StringSegment.HasValue"/> property will be <see langword="false"/>.
+	/// </returns>
+	public static StringSegment First(this StringSegment source, StringSegment search, StringComparison comparisonType = StringComparison.Ordinal)
+	{
+		if (!source.HasValue) throw new ArgumentException(MustBeSegmentWithValue, nameof(source));
+		Contract.EndContractBlock();
+
+		if (search.Length == 0)
+			return default;
+
+		var i = source.IndexOf(search, comparisonType);
+		return i == -1 ? default : source.Subsegment(i, search.Length);
+	}
+
+	/// <inheritdoc cref="First(StringSegment, StringSegment, StringComparison)"/>
+	public static StringSegment First(this StringSegment source, char search, StringComparison comparisonType = StringComparison.Ordinal)
+	{
+		if (!source.HasValue) throw new ArgumentException(MustBeSegmentWithValue, nameof(source));
+		Contract.EndContractBlock();
+
+		var i = source.IndexOf(search, comparisonType);
+		return i == -1 ? default : source.Subsegment(i, 1);
+	}
+
+	/// <inheritdoc cref="First(StringSegment, StringSegment, StringComparison)"/>
+	public static StringSegment First(this string source, char search, StringComparison comparisonType = StringComparison.Ordinal)
+	{
+		if (source is null) throw new ArgumentNullException(nameof(source));
+		Contract.EndContractBlock();
+
+		var i = source.IndexOf(search, comparisonType);
+		return i == -1 ? default : source.AsSegment(i, 1);
+	}
+
+	/// <inheritdoc cref="First(StringSegment, StringSegment, StringComparison)"/>
+	public static StringSegment First(this string source, StringSegment search, StringComparison comparisonType = StringComparison.Ordinal)
+	{
+		if (source is null) throw new ArgumentNullException(nameof(source));
+		Contract.EndContractBlock();
+
+		return First(source.AsSegment(), search, comparisonType);
+	}
+
+	/// <summary>
+	/// Finds the first instance of a pattern and returns a StringSegment for subsequent use.
+	/// </summary>
+	/// <param name="source">The source string to search.</param>
+	/// <param name="pattern">The pattern to look for.</param>
+	/// <returns>
+	/// The segment representing the found string.
+	/// If not found, the StringSegment.HasValue property will be false.
+	/// </returns>
+	/// <remarks>If the pattern is right-to-left, then it will return the first segment from the right.</remarks>
+	[ExcludeFromCodeCoverage] // Reason: would just test already tested code.
+	public static StringSegment First(this string source, Regex pattern)
+	{
+		if (source is null) throw new ArgumentNullException(nameof(source));
+		if (pattern is null) throw new ArgumentNullException(nameof(pattern));
+		Contract.EndContractBlock();
+
+		var match = pattern.Match(source);
+		return match.Success ? new(source, match.Index, match.Length) : default;
+	}
+
+	/// <inheritdoc cref="First(string, StringSegment, StringComparison)" />
+	public static StringSegment First(this StringSegment source, ReadOnlySpan<char> search, StringComparison comparisonType = StringComparison.Ordinal)
+	{
+		if (!source.HasValue) throw new ArgumentException(MustBeSegmentWithValue, nameof(source));
+		Contract.EndContractBlock();
+
+		if (search.IsEmpty)
+			return default;
+
+		var i = source.AsSpan().IndexOf(search, comparisonType);
+		return i == -1 ? default : new(source.Buffer, source.Offset + i, search.Length);
+	}
+
+	/// <summary>
+	/// Finds the last instance of a string and returns a StringSegment for subsequent use.
+	/// </summary>
+	/// <inheritdoc cref="First(StringSegment, StringSegment, StringComparison)"/>
+	public static StringSegment Last(this StringSegment source, StringSegment search, StringComparison comparisonType = StringComparison.Ordinal)
+	{
+		if (!source.HasValue) throw new ArgumentException(MustBeSegmentWithValue, nameof(source));
+		Contract.EndContractBlock();
+
+		if (search.Length == 0)
+			return default;
+
+		var i = source.AsSpan().LastIndexOf(search, comparisonType);
+		return i == -1 ? default : source.Subsegment(i, search.Length);
+	}
+
+	/// <inheritdoc cref="Last(StringSegment, StringSegment, StringComparison)" />
+	public static StringSegment Last(this string source, StringSegment search, StringComparison comparisonType = StringComparison.Ordinal)
+		=> Last(source.AsSegment(), search, comparisonType);
+
+	/// <summary>
+	/// Finds the last instance of a pattern and returns a StringSegment for subsequent use.
+	/// </summary>
+	/// <remarks>If the pattern is right-to-left, then it will return the last segment from the right (first segment from the left).</remarks>
+	/// <inheritdoc cref="First(string, Regex)"/>
+	public static StringSegment Last(this string source, Regex pattern)
+	{
+		if (source is null) throw new ArgumentNullException(nameof(source));
+		if (pattern is null) throw new ArgumentNullException(nameof(pattern));
+		Contract.EndContractBlock();
+
+		var matches = pattern.Matches(source);
+		if (matches.Count == 0) return default;
+		var match = matches[matches.Count - 1];
+		return new(source, match.Index, match.Length);
+	}
+
+	/// <inheritdoc cref="Last(StringSegment, StringSegment, StringComparison)" />
+	public static StringSegment Last(this StringSegment source, ReadOnlySpan<char> search, StringComparison comparisonType = StringComparison.Ordinal)
+	{
+		if (!source.HasValue) throw new ArgumentException(MustBeSegmentWithValue, nameof(source));
+		Contract.EndContractBlock();
+		if (search.IsEmpty)
+			return default;
+
+		var i = source.AsSpan().LastIndexOf(search, comparisonType);
+		return i == -1 ? default : new(source.Buffer, source.Offset + i, search.Length);
+	}
+}