Merge pull request #20 from draconware-dev/dev

Version 1.3.0

Author: dragon7307

.editorconfig

@@ -2,12 +2,12 @@
 
 # IDE0090: Use 'new(...)'
 csharp_style_implicit_object_creation_when_type_is_apparent = false:silent
-csharp_using_directive_placement = outside_namespace:suggestion
+csharp_using_directive_placement = outside_namespace:warning
 csharp_prefer_simple_using_statement = true:suggestion
 csharp_prefer_braces = true:suggestion
-csharp_style_namespace_declarations = block_scoped:suggestion
+csharp_style_namespace_declarations = block_scoped:error
 csharp_style_prefer_method_group_conversion = true:silent
-csharp_style_prefer_top_level_statements = true:silent
+csharp_style_prefer_top_level_statements = true:suggestion
 csharp_style_expression_bodied_methods = false:silent
 csharp_style_expression_bodied_constructors = false:silent
 csharp_style_expression_bodied_operators = false:silent
@@ -50,6 +50,15 @@ csharp_style_var_when_type_is_apparent = true:suggestion
 csharp_style_var_elsewhere = false:suggestion
 dotnet_diagnostic.CA1001.severity = warning
 dotnet_diagnostic.CA1309.severity = warning
+dotnet_diagnostic.CA1510.severity = none
+csharp_style_prefer_primary_constructors = false:error
+dotnet_diagnostic.CA1311.severity = warning
+dotnet_diagnostic.SYSLIB1054.severity = warning
+dotnet_diagnostic.CA1805.severity = suggestion
+dotnet_diagnostic.CA1825.severity = suggestion
+dotnet_diagnostic.CA1824.severity = warning
+dotnet_diagnostic.CA1870.severity = warning
+csharp_style_prefer_readonly_struct_member = true:suggestion
 
 [*.{cs,vb}]
 #### Naming styles ####
@@ -105,14 +114,14 @@ dotnet_style_prefer_auto_properties = true:silent
 dotnet_style_object_initializer = true:suggestion
 dotnet_style_collection_initializer = true:suggestion
 dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
-dotnet_style_prefer_conditional_expression_over_assignment = true:silent
-dotnet_style_prefer_conditional_expression_over_return = true:silent
+dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion
+dotnet_style_prefer_conditional_expression_over_return = true:suggestion
 dotnet_style_operator_placement_when_wrapping = beginning_of_line
 tab_width = 4
 indent_size = 4
 end_of_line = crlf
 dotnet_style_allow_multiple_blank_lines_experimental = false:suggestion
-dotnet_style_prefer_collection_expression = false
+dotnet_style_prefer_collection_expression = never:silent
 csharp_style_prefer_primary_constructors = false
 dotnet_style_allow_statement_immediately_after_block_experimental = true:silent
 dotnet_style_explicit_tuple_names = true:suggestion
@@ -139,6 +148,14 @@ dotnet_diagnostic.CA1000.severity = silent
 dotnet_diagnostic.CA1304.severity = warning
 dotnet_diagnostic.CA1305.severity = warning
 dotnet_diagnostic.CA1310.severity = warning
+dotnet_diagnostic.CA2101.severity = warning
+dotnet_diagnostic.CA1401.severity = warning
+dotnet_diagnostic.CA1511.severity = none
+dotnet_diagnostic.CA1512.severity = none
+dotnet_diagnostic.CA1806.severity = suggestion
+dotnet_diagnostic.CA1821.severity = warning
+dotnet_diagnostic.CA1826.severity = warning
+dotnet_diagnostic.CA1829.severity = warning
 
 [*.vb]
 dotnet_diagnostic.CA1047.severity = suggestion

.github/README.md

@@ -1,5 +1,7 @@
 # SpanExtensions
 
+[![NuGet Badge](https://buildstats.info/nuget/SpanExtensions.Net)](https://www.nuget.org/packages/SpanExtensions.Net)
+
 ## About
 **`ReadonlySpan<T>`** and **`Span<T>`** are great Types in _C#_, but unfortunately working with them can sometimes be sort of a hassle and some use cases seem straight up impossible, even though they are not.  
 
@@ -9,8 +11,6 @@ Never again switch back to using `string` instead of `ReadonlySpan<T>`, just bec
 
 **SpanExtensions.Net** provides alternatives for many missing Extension Methods for **`ReadonlySpan<T>`** and **`Span<T>`**, ranging from `string.Split()` over `Enumerable.Skip()` and `Enumerable.Take()` to an improved `ReadOnlySpan<T>.IndexOf()`.
 
-**SpanExtensions.Net** may also be found on [NuGet](https://www.nuget.org/packages/SpanExtensions.Net).   
-  
 ## Methods 
 The following **Extension Methods** are contained: 
 
@@ -43,6 +43,38 @@ The following **Extension Methods** are contained:
 - `(ReadOnly-)Span<T>.Takelast(int count)`
 - `(ReadOnly-)Span<T>.SkipWhile(Predicate<T> condition)` 
 - `(ReadOnly-)Span<T>.TakeWhile(Predicate<T> condition)`
+- `(Readonly-)Span<T>.First()`
+- `(Readonly-)Span<T>.First(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.FirstOrDefault()`
+- `(Readonly-)Span<T>.FirstOrDefault(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.FirstOrDefault(T defaultValue)`
+- `(Readonly-)Span<T>.FirstOrDefault(Predicate<T> predicate, T defaultValue)`
+- `(Readonly-)Span<T>.Last()`
+- `(Readonly-)Span<T>.Last(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.LastOrDefault()`
+- `(Readonly-)Span<T>.LastOrDefault(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.LastOrDefault(T defaultValue)`
+- `(Readonly-)Span<T>.LastOrDefault(Predicate<T> predicate, T defaultValue)`
+- `(Readonly-)Span<T>.Single()`
+- `(Readonly-)Span<T>.Single(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.SingleOrDefault()`
+- `(Readonly-)Span<T>.SingleOrDefault(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.SingleOrDefault(T defaultValue)`
+- `(Readonly-)Span<T>.SingleOrDefault(Predicate<T> predicate, T defaultValue)`
+- `(Readonly-)Span<T>.ElementAt(int index)`
+- `(Readonly-)Span<T>.ElementAt(Index index)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(int index)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(Index index)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(int index, T defaultValue)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(Index index, T defaultValue)`
+- `(Readonly-)Span<T>.Min()`
+- `(Readonly-)Span<T>.Min(Func<TSource, TResult> selector)`
+- `(Readonly-)Span<T>.MinBy(Func<TSource, TKey> keySelector)`
+- `(Readonly-)Span<T>.MinBy(Func<TSource, TKey> keySelector, IComparer<TKey> comparer)`
+- `(Readonly-)Span<T>.Max()`
+- `(Readonly-)Span<T>.Max(Func<TSource, TResult> selector)`
+- `(Readonly-)Span<T>.MaxBy(Func<TSource, TKey> keySelector)`
+- `(Readonly-)Span<T>.MaxBy(Func<TSource, TKey> keySelector, IComparer<TKey> comparer)`
 
 ## Contributing
 
@@ -51,4 +83,4 @@ Thank you for your interest in contributing to this project - Please see [Contri
 
 Copyright (c) draconware-dev. All rights reserved. 
 
-Licensed under the [MIT](../LICENSE) license.
+Licensed under the [MIT](../LICENSE) License.

.github/workflows/dotnet.yml

@@ -0,0 +1,29 @@
+
+name: .NET
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "dev" ]
+    paths:
+    - '**.cs'
+    - '**.csproj'
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+        
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 8.0.x
+    - name: Restore dependencies
+      run: dotnet restore
+    - name: Build
+      run: dotnet build --no-restore
+    - name: Test
+      run: dotnet test --no-build --verbosity normal

Changelog.md

@@ -5,18 +5,63 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3] - 2024-3-19
+
+### Added 
+
+- Compatibility with **.Net 8**
+- `(Readonly-)Span<T>.First()`
+- `(Readonly-)Span<T>.First(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.FirstOrDefault()`
+- `(Readonly-)Span<T>.FirstOrDefault(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.FirstOrDefault(T defaultValue)`
+- `(Readonly-)Span<T>.FirstOrDefault(Predicate<T> predicate, T defaultValue)`
+- `(Readonly-)Span<T>.Last()`
+- `(Readonly-)Span<T>.Last(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.LastOrDefault()`
+- `(Readonly-)Span<T>.LastOrDefault(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.LastOrDefault(T defaultValue)`
+- `(Readonly-)Span<T>.LastOrDefault(Predicate<T> predicate, T defaultValue)`
+- `(Readonly-)Span<T>.Single()`
+- `(Readonly-)Span<T>.Single(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.SingleOrDefault()`
+- `(Readonly-)Span<T>.SingleOrDefault(Predicate<T> predicate)`
+- `(Readonly-)Span<T>.SingleOrDefault(T defaultValue)`
+- `(Readonly-)Span<T>.SingleOrDefault(Predicate<T> predicate, T defaultValue)`
+- `(Readonly-)Span<T>.ElementAt(int index)`
+- `(Readonly-)Span<T>.ElementAt(Index index)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(int index)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(Index index)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(int index, T defaultValue)`
+- `(Readonly-)Span<T>.ElementAtOrDefault(Index index, T defaultValue)`
+- `(Readonly-)Span<T>.Min()` (https://github.com/draconware-dev/SpanExtensions.Net/pull/13)
+- `(Readonly-)Span<T>.Min(Func<TSource, TResult> selector)`
+- `(Readonly-)Span<T>.MinBy(Func<TSource, TKey> keySelector)`
+- `(Readonly-)Span<T>.MinBy(Func<TSource, TKey> keySelector, IComparer<TKey> comparer)`
+- `(Readonly-)Span<T>.Max()` (https://github.com/draconware-dev/SpanExtensions.Net/pull/13)
+- `(Readonly-)Span<T>.Max(Func<TSource, TResult> selector)`
+- `(Readonly-)Span<T>.MaxBy(Func<TSource, TKey> keySelector)`
+- `(Readonly-)Span<T>.MaxBy(Func<TSource, TKey> keySelector, IComparer<TKey> comparer)`
+- nuget badge to README (https://github.com/draconware-dev/SpanExtensions.Net/pull/12)
+- `CountExceedingBehaviour`, which is passed to Split, defining how to properly handle its remaining elements.
+
+### Changed 
+
+- documentation comments to better reflect the dotnet style (https://github.com/draconware-dev/SpanExtensions.Net/pull/8)
+- swapped order of `count` and `stringSplitOptions arguments` in `Split` methods.
+- renamed argument `span` in `Split` methods to `source`.
+
+### Fixed 
+
+- empty spans being ignored if they are the last element to be returned from `Split` and are therefore not returned. (https://github.com/draconware-dev/SpanExtensions.Net/pull/10)
+
 ## [1.2.1] - 2024-1-25
 
 ### Fixed 
 
 - Ambiguous Extension Methods (https://github.com/draconware-dev/SpanExtensions.Net/issues/6)
 - Correctness of some documentation comments     
 
-### Changed 
-
-- moved custom Enumerators into `SpanExtensions.Enumerators` 
-- declared every `GetEnumerator` method in a ref struct as `readonly`
-
 ## [1.2.0] - 2023-12-28
 
 ### Added 

src/CountExceedingBehaviour.cs

@@ -0,0 +1,17 @@
+namespace SpanExtensions
+{
+    /// <summary>
+    /// Defines the behaviour of a split operation when there are more split instances than there may be. 
+    /// </summary>
+    public enum CountExceedingBehaviour
+    {
+        /// <summary>
+        /// The last element returned will be all the remaining elements appended as one.
+        /// </summary>
+        AppendRemainingElements,
+        /// <summary>
+        /// Every split instance more than permitted will not be returned. 
+        /// </summary>
+        CutRemainingElements
+    }
+}

src/Enumerators/Split/SpanSplitEnumerator.cs

@@ -5,29 +5,34 @@ namespace SpanExtensions.Enumerators
     /// <summary>
     /// Supports iteration over a <see cref="ReadOnlySpan{T}"/> by splitting it at a specified delimiter of type <typeparamref name="T"/>.
     /// </summary>
-    /// <typeparam name="T">The type of elements in the enumerated <see cref="ReadOnlySpan{T}"/></typeparam>
+    /// <typeparam name="T">The type of elements in the enumerated <see cref="ReadOnlySpan{T}"/>.</typeparam>
     public ref struct SpanSplitEnumerator<T> where T : IEquatable<T>
     {
         ReadOnlySpan<T> Span;
         readonly T Delimiter;
+        bool enumerationDone;
 
         /// <summary>
-        /// Gets the element in the collection at the current position of the enumerator. 
+        /// Gets the element in the collection at the current position of the enumerator.
         /// </summary>
         public ReadOnlySpan<T> Current { get; internal set; }
 
         /// <summary>
-        /// Constructs a <see cref="SpanSplitEnumerator{T}"/> from a span and a delimiter. ONLY CONSUME THIS CLASS THROUGH <see cref="ReadOnlySpanExtensions.Split{T}(ReadOnlySpan{T}, T)"/>. 
+        /// Constructs a <see cref="SpanSplitEnumerator{T}"/> from a span and a delimiter. <strong>Only consume this class through <see cref="ReadOnlySpanExtensions.Split{T}(ReadOnlySpan{T}, T)"/></strong>.
         /// </summary>
-        /// <param name="source">The <see cref="ReadOnlySpan{T}"/> to be split.</param>  
-        /// <param name="delimiter">An instance of <typeparamref name="T"/> that delimits the various sub-ReadOnlySpans in the <see cref="ReadOnlySpan{T}"/>.</param>
+        /// <param name="source">The <see cref="ReadOnlySpan{T}"/> to be split.</param>
+        /// <param name="delimiter">An instance of <typeparamref name="T"/> that delimits the various sub-ReadOnlySpans in <paramref name="source"/>.</param>
         public SpanSplitEnumerator(ReadOnlySpan<T> source, T delimiter)
         {
             Span = source;
             Delimiter = delimiter;
             Current = default;
+            enumerationDone = false;
         }
-        /// <summary></summary>
+
+        /// <summary>
+        /// Returns an enumerator that iterates through a collection.
+        /// </summary>
         public readonly SpanSplitEnumerator<T> GetEnumerator()
         {
             return this;
@@ -36,19 +41,20 @@ public readonly SpanSplitEnumerator<T> GetEnumerator()
         /// <summary>
         /// Advances the enumerator to the next element of the collection.
         /// </summary>
-        /// <returns><code>true</code> if the enumerator was successfully advanced to the next element; <code>false</code> if the enumerator has passed the end of the collection.</returns>
+        /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<T> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<T> span = Span;
             int index = span.IndexOf(Delimiter);
 
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<T>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }