The most significant changes include the addition of new classes and structures to handle character sequences and their enumeration. The CharacterSequence struct, StringBuilderEnumerator struct, StringConcat class, and StringSegmentEnumerator struct have been added to represent and manipulate sequences of characters. Additionally, the Equals method in both StringComparable.cs and StringSubsegment.cs has been updated to allow for nullable objects.

Here is a list of the changes:

1. The `Equals` method in `StringComparable.cs` has been updated to allow for nullable objects. This change enhances the method's flexibility in handling different types of inputs.
2. The `GetHashCode` method in `StringComparable.cs` has been updated to handle different .NET Standard versions. This ensures the method's compatibility across different .NET Standard versions.
3. The `StringSegmentComparer` class in `StringSegmentComparer.cs` has been updated to include additional parameters in the constructor and their corresponding properties. This allows for more detailed object instantiation.
4. The `Equals` method in `StringSubsegment.cs` has been updated to allow for nullable objects. This enhances the method's flexibility in handling different types of inputs.
5. A new `CharacterSequence` struct has been added in `CharacterSequence.cs` to represent a sequence of characters. This provides a new way to handle character sequences.
6. A new `StringBuilderEnumerator` struct has been added in `StringBuilderEnumerator.cs` to enumerate the characters in a `StringBuilder`. This provides a new way to iterate through the characters in a `StringBuilder`.
7. A new `StringConcat` class has been added in `StringConcat.cs` to concatenate sequences of characters. This provides a new way to concatenate character sequences.
8. A new `StringSegmentEnumerator` struct has been added in `StringSegmentEnumerator.cs` to enumerate the characters in a `StringSegment`. This provides a new way to iterate through the characters in a `StringSegment`.
9. New tests for the `StringConcat` class have been added in `StringConcatTests.cs`. This ensures the `StringConcat` class functions as expected.

Author: electricessence

.editorconfig

@@ -220,6 +220,8 @@ csharp_style_prefer_top_level_statements = true:silent
 csharp_style_prefer_local_over_anonymous_function = true:suggestion
 csharp_style_prefer_tuple_swap = true:suggestion
 csharp_style_prefer_utf8_string_literals = true:suggestion
+csharp_style_prefer_primary_constructors = true:suggestion
+dotnet_diagnostic.SYSLIB1045.severity = silent
 
 [*.{cs,vb}]
 dotnet_style_operator_placement_when_wrapping = beginning_of_line
@@ -244,4 +246,7 @@ dotnet_style_prefer_inferred_tuple_names = true:suggestion
 dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
 dotnet_style_prefer_compound_assignment = true:suggestion
 dotnet_style_prefer_simplified_interpolation = true:suggestion
-dotnet_style_namespace_match_folder = true:suggestion
+dotnet_style_namespace_match_folder = true:suggestion
+dotnet_diagnostic.CA1510.severity = silent
+dotnet_diagnostic.CA1512.severity = silent
+dotnet_diagnostic.CA1863.severity = none

Source/CharacterSequence.cs

@@ -0,0 +1,204 @@
+using Microsoft.Extensions.Primitives;
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics;
+
+namespace Open.Text;
+
+/// <summary>
+/// A read-only struct that represents a sequence of characters.
+/// </summary>
+[SuppressMessage("Usage", "CA2225:Operator overloads have named alternates")]
+public readonly record struct CharacterSequence : IEnumerable<char>
+{
+	private readonly int _length;
+	private readonly Func<int>? _getLength;
+	private readonly Func<string>? _toString;
+
+	/// <summary>
+	/// Indicates whether the sequence is empty.
+	/// </summary>
+	/// <remarks>
+	/// Can still return <see langword="false"/> if the sequence could have a length that potentially changes.
+	/// </remarks>
+	public bool IsEmpty => _length == 0;
+
+	/// <summary>
+	/// The number of characters in the sequence.
+	/// </summary>
+	public readonly int Length
+		=> _length == -1 ? _getLength!() : _length;
+
+	/// <summary>
+	/// The characters in the sequence.
+	/// </summary>
+	public readonly IEnumerable<char> Characters { get; }
+
+	/// <summary>
+	/// Constructs a CharacterSequence.
+	/// </summary>
+	private CharacterSequence(int length, IEnumerable<char> characters, Func<string>? toString = null)
+	{
+		Debug.Assert(length >= 0);
+
+		_length = length;
+		_toString = toString;
+		Characters = characters;
+	}
+
+	private CharacterSequence(Func<int> getLength, IEnumerable<char> characters, Func<string>? toString = null)
+	{
+		_length = -1;
+		_getLength = getLength;
+		_toString = toString;
+		Characters = characters;
+	}
+
+	/// <summary>
+	/// An empty CharacterSequence.
+	/// </summary>
+	public static CharacterSequence Empty { get; } = new(0, []);
+
+	/// <summary>
+	/// Creates a new <see cref="CharacterSequence"/> from the specified characters.
+	/// </summary>
+	/// <remarks>Returns <see cref="Empty"/> if the <paramref name="length"/> is zero.</remarks>
+	internal static CharacterSequence Create(int length, IEnumerable<char> characters)
+		=> length == 0 ? Empty : new(length, characters);
+
+	/// <summary>
+	/// Creates a new <see cref="CharacterSequence"/> from the specified characters.
+	/// </summary>
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static CharacterSequence Create(Func<int> getLength, IEnumerable<char> characters)
+		=> new(getLength, characters);
+
+	/// <summary>
+	/// Implicitly converts a <see cref="StringSegment"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(string characters)
+	{
+		if (characters is null) return Empty;
+		var len = characters.Length;
+		return len == 0 ? Empty : new(len, characters, characters.ToString);
+	}
+
+	/// <summary>
+	/// Implicitly converts a <see cref="char"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(char value)
+		=> new(1, Enumerable.Repeat(value, 1));
+
+	/// <summary>
+	/// Implicitly converts a <see cref="StringSegment"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(StringSegment characters)
+	{
+		var len = characters.Length;
+		return len == 0 ? Empty : new(len, characters.AsEnumerable(), characters.ToString);
+	}
+
+	/// <summary>
+	/// Implicitly converts a <see cref="ArraySegment{T}"/> of <see cref="char"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(ArraySegment<char> characters)
+		=> Create(characters.Count, characters);
+
+	/// <summary>
+	/// Implicitly converts a <see cref="ArraySegment{T}"/> of <see cref="char"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(char[] characters)
+	{
+		if (characters is null) return Empty;
+		var len = characters.Length;
+		return len == 0 ? Empty : new(len, characters, () => new string(characters));
+	}
+
+	/// <summary>
+	/// Implicitly converts a <see cref="ReadOnlyMemory{T}"/> of <see cref="char"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(ReadOnlyMemory<char> characters)
+	{
+		var len = characters.Length;
+		return len == 0 ? Empty : new(len, GetChars(characters), () => characters.Span.ToString());
+
+		static IEnumerable<char> GetChars(ReadOnlyMemory<char> memory)
+		{
+			var len = memory.Length;
+			for (int i = 0; i < len; i++)
+				yield return memory.Span[i];
+		}
+	}
+
+	/// <summary>
+	/// Implicitly converts a <see cref="Memory{T}"/> of <see cref="char"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(Memory<char> characters)
+		=> (ReadOnlyMemory<char>)characters;
+
+	/// <summary>
+	/// Implicitly converts a <see cref="ArraySegment{T}"/> of <see cref="char"/> to a <see cref="CharacterSequence"/>.
+	/// </summary>
+	public static implicit operator CharacterSequence(StringBuilder characters)
+		=> characters is null ? Empty : new(() => characters.Length, characters.AsEnumerable(), characters.ToString);
+
+	/// <summary>
+	/// Copies the characters in the sequence to a string.
+	/// </summary>
+	public override string ToString()
+	{
+		if (_toString is not null)
+			return _toString();
+
+		var len = Length;
+		if (len == 0) return string.Empty;
+
+		const int MaxStackSize = 256;
+		if (len > MaxStackSize)
+		{
+			using var lease = MemoryPool<char>.Shared.Rent(len);
+			var span = lease.Memory.Span.Slice(0, len);
+			CopyTo(span);
+			var result = span.ToString();
+			span.Clear(); // This is important for security reasons.
+			return result;
+		}
+		else
+		{
+			Span<char> allocated = stackalloc char[MaxStackSize];
+			var span = allocated.Slice(0, len);
+			CopyTo(span);
+			return span.ToString();
+		}
+	}
+
+	/// <summary>
+	/// Copies the characters in the sequence to a span.
+	/// </summary>
+	public void CopyTo(Span<char> span)
+	{
+		var e = Characters.GetEnumerator();
+		for (int i = 0; i < span.Length; i++)
+		{
+			if (!e.MoveNext())
+				throw new InvalidOperationException("The sequence is shorter than the specified length.");
+			span[i] = e.Current;
+		}
+
+		if (e.MoveNext())
+			throw new InvalidOperationException("The sequence is longer than the specified length.");
+	}
+
+	/// <inheritdoc />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public IEnumerator<char> GetEnumerator() => Characters.GetEnumerator();
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}