Code style cleanup: expression-bodied members and formatting

Author: electricessence

Benchmarks/AllocationBaselineBenchmark.cs

@@ -4,7 +4,6 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Order;
-using Open.Text;
 using ZLinq;
 
 namespace Open.Text.Benchmarks;
@@ -65,10 +64,7 @@ public int Small_ToArray()
 	}
 
 	[Benchmark(Description = "Small - Count()")]
-	public int Small_Count()
-	{
-		return SmallString.AsSegment().SplitAsSegments(',').Count();
-	}
+	public int Small_Count() => SmallString.AsSegment().SplitAsSegments(',').Count();
 
 	// ========== Medium String Tests ==========
 
@@ -85,21 +81,17 @@ public int Medium_ForeachOnly()
 
 	[Benchmark(Description = "Medium - LINQ Where")]
 	public int Medium_LinqWhere()
-	{
-		return MediumString.AsSegment()
+		=> MediumString.AsSegment()
 			.SplitAsSegments(',')
 			.Where(s => s.Length > 5)
 			.Count();
-	}
 
 	[Benchmark(Description = "Medium - LINQ Select")]
 	public int Medium_LinqSelect()
-	{
-		return MediumString.AsSegment()
+		=> MediumString.AsSegment()
 			.SplitAsSegments(',')
 			.Select(s => s.Length)
 			.Sum();
-	}
 
 	// ========== Large String Tests ==========
 

Benchmarks/SplitAsSegmentsQuickTest.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics;
-using Open.Text;
 using ZLinq;
 
 namespace Open.Text.Benchmarks;
@@ -20,7 +18,7 @@ public static void Run()
 		Console.WriteLine("Test 1: Simple foreach (only counting)");
 		long gen0Before = GC.CollectionCount(0);
 		long memBefore = GC.GetTotalMemory(forceFullCollection: true);
-		
+
 		int count = 0;
 		for (int i = 0; i < 10000; i++)
 		{
@@ -29,10 +27,10 @@ public static void Run()
 				count += segment.Length;
 			}
 		}
-		
+
 		long memAfter = GC.GetTotalMemory(forceFullCollection: false);
 		long gen0After = GC.CollectionCount(0);
-		
+
 		Console.WriteLine($"  Result: {count}");
 		Console.WriteLine($"  Memory allocated: ~{(memAfter - memBefore) / 1024}KB");
 		Console.WriteLine($"  Gen0 collections: {gen0After - gen0Before}");
@@ -42,16 +40,16 @@ public static void Run()
 		Console.WriteLine("Test 2: With LINQ Count()");
 		gen0Before = GC.CollectionCount(0);
 		memBefore = GC.GetTotalMemory(forceFullCollection: true);
-		
+
 		int totalCount = 0;
 		for (int i = 0; i < 10000; i++)
 		{
 			totalCount += testString.AsSegment().SplitAsSegments(',').Count();
 		}
-		
+
 		memAfter = GC.GetTotalMemory(forceFullCollection: false);
 		gen0After = GC.CollectionCount(0);
-		
+
 		Console.WriteLine($"  Result: {totalCount}");
 		Console.WriteLine($"  Memory allocated: ~{(memAfter - memBefore) / 1024}KB");
 		Console.WriteLine($"  Gen0 collections: {gen0After - gen0Before}");
@@ -61,17 +59,17 @@ public static void Run()
 		Console.WriteLine("Test 3: With ToArray()");
 		gen0Before = GC.CollectionCount(0);
 		memBefore = GC.GetTotalMemory(forceFullCollection: true);
-		
+
 		int arrayCount = 0;
 		for (int i = 0; i < 10000; i++)
 		{
 			var arr = testString.AsSegment().SplitAsSegments(',').ToArray();
 			arrayCount += arr.Length;
 		}
-		
+
 		memAfter = GC.GetTotalMemory(forceFullCollection: false);
 		gen0After = GC.CollectionCount(0);
-		
+
 		Console.WriteLine($"  Result: {arrayCount}");
 		Console.WriteLine($"  Memory allocated: ~{(memAfter - memBefore) / 1024}KB");
 		Console.WriteLine($"  Gen0 collections: {gen0After - gen0Before}");

Benchmarks/ZLinqImprovementsBenchmark.cs

@@ -4,8 +4,6 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Order;
-using Microsoft.Extensions.Primitives;
-using Open.Text;
 using System.Text.RegularExpressions;
 using ZLinq;
 
@@ -38,7 +36,7 @@ public Config()
 	private const string SmallCsv = "apple,banana,cherry,date,elderberry";
 	private const string MediumCsv = "apple,banana,cherry,date,elderberry,fig,grape,honeydew,kiwi,lemon,mango,nectarine,orange,papaya,quince";
 	private static readonly string LargeCsv = string.Join(",", Enumerable.Range(1, 1000).Select(i => $"item{i}"));
-	
+
 	private static readonly Regex CommaRegex = new(",", RegexOptions.Compiled);
 	private static readonly Regex WordRegex = new(@"\w+", RegexOptions.Compiled);
 
@@ -70,15 +68,15 @@ public int CharSplit_Foreach_ZLinq()
 
 	[BenchmarkCategory("CharSplit-Count"), Benchmark(Baseline = true, Description = "BCL Split + LINQ Count")]
 	public int CharSplit_Count_BCL()
-	{
-		return SmallCsv.Split(',').Count();
-	}
+#pragma warning disable CA1829 // Use Length/Count property instead of Count() when available
+#pragma warning disable RCS1077 // Optimize LINQ method call
+		=> SmallCsv.Split(',').Count();
+#pragma warning restore RCS1077 // Optimize LINQ method call
+#pragma warning restore CA1829 // Use Length/Count property instead of Count() when available
 
 	[BenchmarkCategory("CharSplit-Count"), Benchmark(Description = "SplitAsSegments + ZLinq Count")]
 	public int CharSplit_Count_ZLinq()
-	{
-		return SmallCsv.SplitAsSegments(',').Count();
-	}
+		=> SmallCsv.SplitAsSegments(',').Count();
 
 	// =====================================================================
 	// CATEGORY: Char Split - Large String Foreach
@@ -173,52 +171,37 @@ public int RegexMatch_ZLinq()
 	// =====================================================================
 
 	[BenchmarkCategory("Replace"), Benchmark(Baseline = true, Description = "BCL String.Replace")]
-	public string Replace_BCL()
-	{
-		return MediumCsv.Replace(",", " | ");
-	}
+	public string Replace_BCL() => MediumCsv.Replace(",", " | ");
 
 	[BenchmarkCategory("Replace"), Benchmark(Description = "ReplaceToString (ZLinq)")]
-	public string Replace_ZLinq()
-	{
-		return MediumCsv.AsSegment().ReplaceToString(",", " | ");
-	}
+	public string Replace_ZLinq() => MediumCsv.AsSegment().ReplaceToString(",", " | ");
 
 	// =====================================================================
 	// CATEGORY: LINQ Chain - Where + Select + Count
 	// =====================================================================
 
 	[BenchmarkCategory("LinqChain"), Benchmark(Baseline = true, Description = "BCL + LINQ Chain")]
 	public int LinqChain_BCL()
-	{
-		return SmallCsv.Split(',')
+		=> SmallCsv.Split(',')
 			.Where(s => s.Length > 4)
-			.Select(s => s.Length)
-			.Sum();
-	}
+			.Sum(s => s.Length);
 
 	[BenchmarkCategory("LinqChain"), Benchmark(Description = "ZLinq Chain")]
 	public int LinqChain_ZLinq()
-	{
-		return SmallCsv.SplitAsSegments(',')
+		=> SmallCsv.SplitAsSegments(',')
 			.Where(s => s.Length > 4)
 			.Select(s => s.Length)
 			.Sum();
-	}
 
 	// =====================================================================
 	// CATEGORY: ToArray Materialization
 	// =====================================================================
 
 	[BenchmarkCategory("ToArray"), Benchmark(Baseline = true, Description = "BCL Split (already array)")]
 	public int ToArray_BCL()
-	{
-		return SmallCsv.Split(',').Length;
-	}
+		=> SmallCsv.Split(',').Length;
 
 	[BenchmarkCategory("ToArray"), Benchmark(Description = "SplitAsSegments.ToArray()")]
 	public int ToArray_ZLinq()
-	{
-		return SmallCsv.SplitAsSegments(',').ToArray().Length;
-	}
+		=> SmallCsv.SplitAsSegments(',').ToArray().Length;
 }

Source/EnumValue.cs

@@ -234,8 +234,7 @@ internal static Entry[]?[] Lookup
 	/// Indicates whether this instance matches the <typeparamref name="TEnum"/> value of <paramref name="other"/>.
 	/// </summary>
 	/// <returns>true if <paramref name="other"/>'s <typeparamref name="TEnum"/> value and this instance's <typeparamref name="TEnum"/> value are the same; otherwise false.</returns>
-	public bool Equals(EnumValue<TEnum> other)
-		=> Value.Equals(other.Value);
+	public bool Equals(EnumValue<TEnum> other) => Value.Equals(other.Value);
 
 	/// <summary>
 	/// Compares an <see cref="EnumValue{TEnum}"/> and <see cref="EnumValueCaseIgnored{TEnum}"/> for <typeparamref name="TEnum"/> equality.
@@ -250,8 +249,7 @@ public bool Equals(EnumValue<TEnum> other)
 		=> !left.Value.Equals(right.Value);
 
 	/// <inheritdoc cref="Equals(EnumValue{TEnum})"/>
-	public bool Equals(EnumValueCaseIgnored<TEnum> other)
-		=> Value.Equals(other.Value);
+	public bool Equals(EnumValueCaseIgnored<TEnum> other) => Value.Equals(other.Value);
 
 	/// <summary>
 	/// Compares two <see cref="EnumValue{TEnum}"/> for <typeparamref name="TEnum"/> equality.
@@ -269,8 +267,7 @@ public bool Equals(EnumValueCaseIgnored<TEnum> other)
 	/// Indicates whether this instance matches the provided enum <paramref name="other"/>.
 	/// </summary>
 	/// <returns>true if <paramref name="other"/> and this instance's enum value are the same; otherwise false.</returns>
-	public bool Equals(TEnum? other)
-		=> Value.Equals(other);
+	public bool Equals(TEnum? other) => Value.Equals(other);
 
 	/// <summary>
 	/// Compares an <see cref="EnumValue{TEnum}"/> and a <typeparamref name="TEnum"/> value forequality.
@@ -285,10 +282,9 @@ public bool Equals(TEnum? other)
 		=> !left.Value.Equals(right);
 
 	/// <inheritdoc />
-	public override bool Equals(object? obj)
-		=> obj is TEnum e && Value.Equals(e)
-		|| obj is EnumValue<TEnum> v1 && Value.Equals(v1.Value)
-		|| obj is EnumValueCaseIgnored<TEnum> v2 && Value.Equals(v2.Value);
+	public override bool Equals(object? obj) => obj is TEnum e && Value.Equals(e)
+			|| obj is EnumValue<TEnum> v1 && Value.Equals(v1.Value)
+			|| obj is EnumValueCaseIgnored<TEnum> v2 && Value.Equals(v2.Value);
 
 	/// <inheritdoc />
 	public override int GetHashCode() => Value.GetHashCode();
@@ -342,15 +338,13 @@ static Underlying()
 	/// </summary>
 	[SuppressMessage("Roslynator", "RCS1158:Static member in generic type should use a type parameter.")]
 	public static bool IsDefined<T>(T value)
-		where T : notnull
-		=> Underlying<T>.Map.ContainsKey(value);
+		where T : notnull => Underlying<T>.Map.ContainsKey(value);
 
 	/// <summary>
 	/// Returns the <typeparamref name="TEnum"/> from the <paramref name="value"/> provided if it maps directly to the underlying value.
 	/// </summary>
 	public static bool TryGetValue<T>(T value, out TEnum e)
-		where T : notnull
-		=> Underlying<T>.Map.TryGetValue(value, out e!);
+		where T : notnull => Underlying<T>.Map.TryGetValue(value, out e!);
 
 	private string GetDebuggerDisplay()
 	{
@@ -400,8 +394,7 @@ public readonly struct EnumValueCaseIgnored<TEnum>
 		=> !left.Value.Equals(right.Value);
 
 	/// <inheritdoc cref="EnumValue{TEnum}.Equals(EnumValue{TEnum})"/>
-	public bool Equals(EnumValueCaseIgnored<TEnum> other)
-		=> Value.Equals(other.Value);
+	public bool Equals(EnumValueCaseIgnored<TEnum> other) => Value.Equals(other.Value);
 
 	/// <summary>
 	/// Compares two <see cref="EnumValueCaseIgnored{TEnum}"/> for <typeparamref name="TEnum"/> equality.
@@ -416,8 +409,7 @@ public bool Equals(EnumValueCaseIgnored<TEnum> other)
 		=> !left.Value.Equals(right.Value);
 
 	/// <inheritdoc cref="EnumValue{TEnum}.Equals(TEnum)"/>
-	public bool Equals(TEnum? other)
-		=> Value.Equals(other);
+	public bool Equals(TEnum? other) => Value.Equals(other);
 
 	/// <summary>
 	/// Compares an <see cref="EnumValueCaseIgnored{TEnum}"/> and a <typeparamref name="TEnum"/> value for equality.
@@ -432,14 +424,12 @@ public bool Equals(TEnum? other)
 		=> !left.Value.Equals(right);
 
 	/// <inheritdoc />
-	public override bool Equals(object? obj)
-		=> obj is TEnum e && Value.Equals(e)
-		|| obj is EnumValueCaseIgnored<TEnum> v1 && Value.Equals(v1.Value)
-		|| obj is EnumValue<TEnum> v2 && Value.Equals(v2.Value);
+	public override bool Equals(object? obj) => obj is TEnum e && Value.Equals(e)
+			|| obj is EnumValueCaseIgnored<TEnum> v1 && Value.Equals(v1.Value)
+			|| obj is EnumValue<TEnum> v2 && Value.Equals(v2.Value);
 
 	/// <inheritdoc />
-	public override int GetHashCode()
-		=> Value.GetHashCode();
+	public override int GetHashCode() => Value.GetHashCode();
 
 	/// <summary>
 	/// Implicitly converts an <see cref="EnumValue{TEnum}"/> to an <see cref="EnumValueCaseIgnored{TEnum}"/>.
@@ -515,18 +505,16 @@ public static bool TryParse<TEnum>(string value, out TEnum e)
 	/// <inheritdoc cref="TryParse{TEnum}(StringSegment, bool, out TEnum)"/>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static TEnum Parse<TEnum>(StringSegment value)
-		where TEnum : notnull, Enum
-		=> TryParse<TEnum>(value, false, out TEnum? e) ? e
-		: throw new ArgumentException(string.Format(NotFoundMessage, value), nameof(value));
+		where TEnum : notnull, Enum => TryParse<TEnum>(value, false, out TEnum? e) ? e
+			: throw new ArgumentException(string.Format(NotFoundMessage, value), nameof(value));
 
 	/// <inheritdoc cref="TryParse{TEnum}(StringSegment, bool, out TEnum)"/>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static TEnum Parse<TEnum>(string value, bool ignoreCase)
-		where TEnum : notnull, Enum
-		=> ignoreCase
-			? EnumValue<TEnum>.IgnoreCaseLookup.TryGetValue(value, out TEnum? e) ? e
-				: throw new ArgumentException(string.Format(NotFoundMessage, value), nameof(value))
-			: Parse<TEnum>(value);
+		where TEnum : notnull, Enum => ignoreCase
+				? EnumValue<TEnum>.IgnoreCaseLookup.TryGetValue(value, out TEnum? e) ? e
+					: throw new ArgumentException(string.Format(NotFoundMessage, value), nameof(value))
+				: Parse<TEnum>(value);
 
 	/// <inheritdoc cref="TryParse{TEnum}(StringSegment, bool, out TEnum)"/>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -543,23 +531,20 @@ public static TEnum Parse<TEnum>(StringSegment value, bool ignoreCase)
 	/// <inheritdoc cref="TryParse{TEnum}(StringSegment, bool, out TEnum)"/>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool TryParse<TEnum>(StringSegment value, out TEnum e)
-		where TEnum : notnull, Enum
-		=> TryParse(value, false, out e);
+		where TEnum : notnull, Enum => TryParse(value, false, out e);
 
 	/// <inheritdoc cref="TryParse{TEnum}(StringSegment, bool, out TEnum)"/>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool TryParse<TEnum>(string name, bool ignoreCase, out TEnum e)
-		where TEnum : notnull, Enum
-		=> ignoreCase
-		? EnumValue<TEnum>.IgnoreCaseLookup.TryGetValue(name, out e!)
-		: TryParse(name, out e);
+		where TEnum : notnull, Enum => ignoreCase
+			? EnumValue<TEnum>.IgnoreCaseLookup.TryGetValue(name, out e!)
+			: TryParse(name, out e);
 
 	/// <inheritdoc cref="TryParse{TEnum}(StringSegment, bool, out TEnum)"/>
 	/// <remarks>Can be slightly faster than other ignore-case methods.</remarks>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool TryParseIgnoreCase<TEnum>(string name, out TEnum e)
-	where TEnum : notnull, Enum
-		=> EnumValue<TEnum>.IgnoreCaseLookup.TryGetValue(name, out e!);
+	where TEnum : notnull, Enum => EnumValue<TEnum>.IgnoreCaseLookup.TryGetValue(name, out e!);
 
 	/// <summary>
 	/// Converts the string representation of the name of one or more enumerated constants to an equivalent enumerated object.
@@ -609,8 +594,7 @@ public static bool TryParse<TEnum>(StringSegment name, bool ignoreCase, out TEnu
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static bool TryGetValue<TEnum, T>(T value, out TEnum e)
 		where TEnum : notnull, Enum
-		where T : notnull
-		=> EnumValue<TEnum>.TryGetValue(value, out e);
+		where T : notnull => EnumValue<TEnum>.TryGetValue(value, out e);
 
 	/// <summary>
 	/// Uses an expression tree to do an fast lookup the name of the enum value.
@@ -621,8 +605,7 @@ public static bool TryGetValue<TEnum, T>(T value, out TEnum e)
 	/// <returns>The name of the enum.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static string GetName<TEnum>(this TEnum value)
-		where TEnum : notnull, Enum
-		=> EnumValue<TEnum>.NameLookup(value);
+		where TEnum : notnull, Enum => EnumValue<TEnum>.NameLookup(value);
 
 	/// <summary>
 	/// Retrieves the attributes for a given enum value.