feat: make yielder arguments comparable

* Improve perfomance by reducing boxing.

perf/Tenekon.Coroutines.Benchmark/AsyncIteratorBenchmark.cs

@@ -1,11 +1,12 @@
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using BenchmarkDotNet.Attributes;
 
 namespace Tenekon.Coroutines.Benchmark
 {
     [MemoryDiagnoser]
-    [MediumRunJob]
+    [ShortRunJob]
     public class AsyncIteratorBenchmark
     {
         private const int RunLess = 9;
@@ -23,7 +24,30 @@ public async Task AsyncIterator(int runs)
             var results = new List<int>();
 
             while (await generator.MoveNextAsync()) {
-                results.Add(((YieldReturnArgument<int>)generator.Current).Value);
+                results.Add(Unsafe.As<YieldReturnArgument<int>>(generator.Current).Value);
+            }
+
+            static async Coroutine Generator(int runs)
+            {
+                var run = runs;
+                while (run-- > 0) {
+                    await YieldReturn(run);
+                    await Task.Yield();
+                }
+            }
+        }
+
+        [Benchmark]
+        [Arguments(RunLess)]
+        [Arguments(RunMore)]
+        [Arguments(RunMost)]
+        public async Task CloeableAsyncIterator(int runs)
+        {
+            var generator = Generator(runs).GetAsyncIterator(isCloneable: true);
+            var results = new List<int>();
+
+            while (await generator.MoveNextAsync()) {
+                results.Add(Unsafe.As<YieldReturnArgument<int>>(generator.Current).Value);
             }
 
             static async Coroutine Generator(int runs)

perf/Tenekon.Coroutines.Benchmark/Imports.cs

@@ -1,4 +1,2 @@
 global using static Tenekon.Coroutines.Yielders;
 global using static Tenekon.Coroutines.Yielders.Arguments;
-global using static Tenekon.Coroutines.Iterators.Yielders;
-global using static Tenekon.Coroutines.Iterators.Yielders.Arguments;

src/Tenekon.Coroutines/Coroutines/CompilerServices/ConfiguredCoroutineAwaiter.cs

@@ -45,7 +45,7 @@ public void UnsafeOnCompleted(Action continuation)
         IAsyncIteratorStateMachineHolder theirStateMachineHolder,
         in SuspensionPoint ourSuspensionPoint,
         ref SuspensionPoint theirSuspensionPoint) =>
-        CoroutineAwaiterCore.RenewStateMachineCoroutineAwaiter<TStateMachine, ConfiguredCoroutineAwaiter, ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter, ValueTaskAccessor, Nothing>(
+        CoroutineAwaiterCore.RenewStateMachineCoroutineAwaiter<TStateMachine, ConfiguredCoroutineAwaiter, ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter, ValueTaskAccessor, VoidCoroutineResult>(
             theirStateMachineHolder,
             in ourSuspensionPoint,
             ref theirSuspensionPoint,

src/Tenekon.Coroutines/Coroutines/CompilerServices/CoroutineAwaiter.cs

@@ -44,7 +44,7 @@ public void UnsafeOnCompleted(Action continuation)
         IAsyncIteratorStateMachineHolder theirStateMachineHolder,
         in SuspensionPoint ourSuspensionPoint,
         ref SuspensionPoint theirSuspensionPoint) =>
-        CoroutineAwaiterCore.RenewStateMachineCoroutineAwaiter<TStateMachine, CoroutineAwaiter, ValueTaskAwaiter, ValueTaskAccessor, Nothing>(
+        CoroutineAwaiterCore.RenewStateMachineCoroutineAwaiter<TStateMachine, CoroutineAwaiter, ValueTaskAwaiter, ValueTaskAccessor, VoidCoroutineResult>(
             theirStateMachineHolder,
             in ourSuspensionPoint,
             ref theirSuspensionPoint,

src/Tenekon.Coroutines/Coroutines/Coroutine.cs

@@ -76,7 +76,7 @@ public readonly ConfiguredCoroutineAwaitable ConfigureAwait(bool continueOnCaptu
     public static implicit operator Coroutine(ValueTask task) => new(task);
 
     public readonly IAsyncIterator GetAsyncIterator(in CoroutineContext additiveContext = default, bool isCloneable = false) =>
-        new AsyncIteratorImpl<Nothing>(this, in additiveContext, isCloneable: isCloneable);
+        new AsyncIteratorImpl<VoidCoroutineResult>(this, in additiveContext, isCloneable: isCloneable);
 
     public readonly bool Equals(in Coroutine other) => CoroutineEqualityComparer.Equals(in this, in other);
 

src/Tenekon.Coroutines/Coroutines/CoroutineAwaiterExtensions.cs

@@ -3,7 +3,7 @@
 internal static class CoroutineAwaiterExtensions
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal static void DelegateCompletion(this Task task, IValueTaskCompletionSource<Nothing> completionSource)
+    internal static void DelegateCompletion(this Task task, IValueTaskCompletionSource<VoidCoroutineResult> completionSource)
     {
         var taskAwaiter = task.ConfigureAwait(false).GetAwaiter();
 
@@ -14,7 +14,7 @@ internal static void DelegateCompletion(this Task task, IValueTaskCompletionSour
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static void CompleteSource(in ConfiguredTaskAwaitable.ConfiguredTaskAwaiter taskAwaiter, IValueTaskCompletionSource<Nothing> completionSource)
+        static void CompleteSource(in ConfiguredTaskAwaitable.ConfiguredTaskAwaiter taskAwaiter, IValueTaskCompletionSource<VoidCoroutineResult> completionSource)
         {
             try {
                 taskAwaiter.GetResult();
@@ -51,7 +51,7 @@ static void CompleteSource(in ConfiguredValueTaskAwaitable<TResult>.ConfiguredVa
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal static void DelegateCoroutineCompletion<TAwaiter>(this ref TAwaiter coroutineAwaiter, IValueTaskCompletionSource<Nothing> completionSource)
+    internal static void DelegateCoroutineCompletion<TAwaiter>(this ref TAwaiter coroutineAwaiter, IValueTaskCompletionSource<VoidCoroutineResult> completionSource)
         where TAwaiter : struct, ICriticalNotifyCompletion, ICoroutineAwaiter
     {
         if (coroutineAwaiter.IsCompleted) {
@@ -62,7 +62,7 @@ internal static void DelegateCoroutineCompletion<TAwaiter>(this ref TAwaiter cor
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static void CompleteSource(in TAwaiter coroutineAwaiter, IValueTaskCompletionSource<Nothing> completionSource)
+        static void CompleteSource(in TAwaiter coroutineAwaiter, IValueTaskCompletionSource<VoidCoroutineResult> completionSource)
         {
             try {
                 coroutineAwaiter.GetResult();

src/Tenekon.Coroutines/Coroutines/CoroutineAwaiterStateMachine.cs

@@ -20,13 +20,13 @@ internal interface ICoroutineAwaiterMethodBuilder<TResult>
 
 internal readonly struct CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>(
     in TCoroutineAwaiter awaiter,
-    CoroutineStateMachineHolder<Nothing, CoroutineAwaiterStateMachine<CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>>> stateMachineHolder) : ICoroutineAwaiterMethodBuilder
+    CoroutineStateMachineHolder<VoidCoroutineResult, CoroutineAwaiterStateMachine<CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>>> stateMachineHolder) : ICoroutineAwaiterMethodBuilder
     where TCoroutineAwaiter : struct, ICriticalNotifyCompletion, ICoroutineAwaiter
 {
     public readonly bool IsCompleted => _awaiter.IsCompleted;
 
     public readonly TCoroutineAwaiter _awaiter = awaiter;
-    public readonly CoroutineStateMachineHolder<Nothing,CoroutineAwaiterStateMachine<CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>>> _stateMachineHolder = stateMachineHolder;
+    public readonly CoroutineStateMachineHolder<VoidCoroutineResult,CoroutineAwaiterStateMachine<CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>>> _stateMachineHolder = stateMachineHolder;
 
     public readonly void AwaitUnsafeOnCompleted() => _awaiter.UnsafeOnCompleted(_stateMachineHolder.MoveNextAction);
 

src/Tenekon.Coroutines/Coroutines/CoroutineContext.cs

@@ -1,4 +1,5 @@
 using System.ComponentModel;
+using Tenekon.Coroutines.Sources;
 
 namespace Tenekon.Coroutines;
 
@@ -53,7 +54,7 @@ internal static CoroutineContext CreateInternal(
     internal int _identifier;
 #endif
 
-    internal ICoroutineResultStateMachineHolder ResultStateMachine => _resultStateMachine ??= CoroutineStateMachineHolder<Nothing>.s_synchronousSuccessSentinel;
+    internal ICoroutineResultStateMachineHolder ResultStateMachine => _resultStateMachine ??= CoroutineStateMachineHolder<VoidCoroutineResult>.s_synchronousSuccessSentinel;
 
     [Browsable(false)]
     [EditorBrowsable(EditorBrowsableState.Never)]

src/Tenekon.Coroutines/Coroutines/CoroutineMethodBuilder.cs

@@ -11,15 +11,15 @@ public static CoroutineMethodBuilder Create()
 
     public Coroutine Task {
         get {
-            var stateMachineHolder = _stateMachineHolder ??= CoroutineMethodBuilder<Nothing>.CreateWeaklyTyedStateMachineBox();
+            var stateMachineHolder = _stateMachineHolder ??= CoroutineMethodBuilder<VoidCoroutineResult>.CreateWeaklyTyedStateMachineBox();
             return new Coroutine(new ValueTask(stateMachineHolder, stateMachineHolder.Version), stateMachineHolder);
         }
     }
 
-    private CoroutineStateMachineHolder<Nothing> _stateMachineHolder;
+    private CoroutineStateMachineHolder<VoidCoroutineResult> _stateMachineHolder;
 
     public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine =>
-        _ = CoroutineMethodBuilder<Nothing>.GetStateMachineHolder(ref stateMachine, ref _stateMachineHolder);
+        _ = CoroutineMethodBuilder<VoidCoroutineResult>.GetStateMachineHolder(ref stateMachine, ref _stateMachineHolder);
 
     public readonly void SetException(Exception e) => _stateMachineHolder.SetException(e);
 
@@ -29,17 +29,17 @@ public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMac
     public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
         where TAwaiter : INotifyCompletion
         where TStateMachine : IAsyncStateMachine =>
-        CoroutineMethodBuilder<Nothing>.AwaitOnCompleted(ref awaiter, ref stateMachine, ref _stateMachineHolder);
+        CoroutineMethodBuilder<VoidCoroutineResult>.AwaitOnCompleted(ref awaiter, ref stateMachine, ref _stateMachineHolder);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
         where TAwaiter : ICriticalNotifyCompletion
         where TStateMachine : IAsyncStateMachine =>
-        CoroutineMethodBuilder<Nothing>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref _stateMachineHolder);
+        CoroutineMethodBuilder<VoidCoroutineResult>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref _stateMachineHolder);
 
-    internal IAsyncIteratorStateMachineHolder<Nothing> ReplaceCoroutineUnderlyingStateMachine<TStateMachine>(ref TStateMachine stateMachine)
+    internal IAsyncIteratorStateMachineHolder<VoidCoroutineResult> ReplaceCoroutineUnderlyingStateMachine<TStateMachine>(ref TStateMachine stateMachine)
         where TStateMachine : IAsyncStateMachine =>
-        CoroutineMethodBuilder<Nothing>.RenewCoroutineStateMachineHolder(ref stateMachine, ref _stateMachineHolder);
+        CoroutineMethodBuilder<VoidCoroutineResult>.RenewCoroutineStateMachineHolder(ref stateMachine, ref _stateMachineHolder);
 
     public void SetStateMachine(IAsyncStateMachine stateMachine) => throw new NotImplementedException();
 }

src/Tenekon.Coroutines/Coroutines/CoroutineMethodBuilderCore.cs

@@ -75,7 +75,7 @@ internal static Coroutine MakeChildCoroutine<TCoroutineAwaiter>(ref TCoroutineAw
         where TCoroutineAwaiter : struct, ICriticalNotifyCompletion, ICoroutineAwaiter
     {
         Debug.Assert(contextToBequest.BequesterOrigin == CoroutineContextBequesterOrigin.ChildCoroutine);
-        var stateMachineHolder = CoroutineStateMachineHolder<Nothing, CoroutineAwaiterStateMachine<CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>>>.RentFromCache();
+        var stateMachineHolder = CoroutineStateMachineHolder<VoidCoroutineResult, CoroutineAwaiterStateMachine<CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>>>.RentFromCache();
         var coroutineBuilder = new CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>(in coroutineAwaiter, stateMachineHolder);
         var stateMachine = new CoroutineAwaiterStateMachine<CoroutineAwaiterMethodBuilder<TCoroutineAwaiter>>(coroutineBuilder) {
             _state = -1

src/Tenekon.Coroutines/Coroutines/CoroutineStateMachineHolder.T.cs

@@ -215,7 +215,7 @@ void IAsyncIteratorStateMachineHolder<TResult>.SetAsyncIteratorCompletionSource(
 
     void IAsyncIteratorStateMachineHolder<TResult>.SetException(Exception e) => _valueTaskSource._valueTaskSource.SetException(e);
 
-    IAsyncIteratorStateMachineHolder<Nothing> IAsyncIteratorStateMachineHolder.CreateNewByCloningUnderlyingStateMachine(
+    IAsyncIteratorStateMachineHolder<VoidCoroutineResult> IAsyncIteratorStateMachineHolder.CreateNewByCloningUnderlyingStateMachine(
         in SuspensionPoint ourSuspensionPoint,
         ref SuspensionPoint theirSuspensionPoint)
     {

src/Tenekon.Coroutines/Coroutines/CoroutineStateMachineHolder.cs

@@ -1,4 +1,5 @@
 using System.Threading.Tasks.Sources;
+using Tenekon.Coroutines.Sources;
 
 namespace Tenekon.Coroutines;
 

src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.cs

@@ -8,11 +8,11 @@ public static class AsyncIterator
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IAsyncIterator Create(Func<Coroutine> provider, in CoroutineContext additiveContext = default, bool isCloneable = false) =>
-        new AsyncIteratorImpl<Nothing>(provider, in additiveContext, isCloneable: isCloneable);
+        new AsyncIteratorImpl<VoidCoroutineResult>(provider, in additiveContext, isCloneable: isCloneable);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IAsyncIterator Create(Coroutine coroutine, in CoroutineContext additiveContext = default, bool isCloneable = false) =>
-        new AsyncIteratorImpl<Nothing>(coroutine, in additiveContext, isCloneable: isCloneable);
+        new AsyncIteratorImpl<VoidCoroutineResult>(coroutine, in additiveContext, isCloneable: isCloneable);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IAsyncIterator<TResult> Create<TResult>(Func<Coroutine<TResult>> provider, in CoroutineContext additiveContext = default, bool isCloneable = false) =>

src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIteratorImpl.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using Tenekon.Coroutines.CompilerServices;
+using Tenekon.Coroutines.Sources;
 
 namespace Tenekon.Coroutines.Iterators;
 
@@ -219,7 +220,7 @@ public void YieldReturn()
                 if ((_nextSuspensionPoint._state & SuspensionPointState.ArgumentSupplied) != 0) {
                     iteratorContext._iteratorContextService._currentSuspensionPoint.RequireAwaiterCompletionNotifier();
                     Debug.Assert(_nextSuspensionPoint._argumentCompletionSource is not null);
-                    _nextSuspensionPoint._argumentCompletionSource.SetResult(default(Nothing)); // ISSUE: hard assumption
+                    _nextSuspensionPoint._argumentCompletionSource.SetResult(default(VoidCoroutineResult)); // ISSUE: hard assumption
                     iteratorContext._coroutineStateMachineHolder?.MoveNext();
                 }
             } finally {
@@ -351,9 +352,9 @@ IAsyncIterator IAsyncIterator.Clone()
             var theirIteratorContextService = new AsyncIteratorContextService(in SuspensionPoint.AwaiterCompletionNotifierRequired, isAsyncIteratorCloneable: true);
             var theirStateMachineHolder = ourStateMachineHolder.CreateNewByCloningUnderlyingStateMachine(in _nextSuspensionPoint, ref theirIteratorContextService._currentSuspensionPoint);
             theirStateMachineHolder.CoroutineContext = ourIteratorContext._iteratorAgnosticCoroutineContext;
-            var theirIterator = new AsyncIteratorImpl<Nothing>(new Coroutine(theirStateMachineHolder, theirStateMachineHolder.Version), _additiveContext, isCloneable: true);
+            var theirIterator = new AsyncIteratorImpl<VoidCoroutineResult>(new Coroutine(theirStateMachineHolder, theirStateMachineHolder.Version), _additiveContext, isCloneable: true);
             { // Initialize their iterator
-                var theirIteratorContext = new AsyncIteratorImpl<Nothing>.AsyncIteratorContext(theirIteratorContextService) {
+                var theirIteratorContext = new AsyncIteratorImpl<VoidCoroutineResult>.AsyncIteratorContext(theirIteratorContextService) {
                     _iteratorAgnosticCoroutineContext = ourIteratorContext._iteratorAgnosticCoroutineContext,
                     _coroutineStateMachineHolder = theirStateMachineHolder,
                     _coroutineAwaiter = theirIterator._coroutineHolder.Coroutine.GetAwaiter()

src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIteratorStateMachineHolder.cs

@@ -6,7 +6,7 @@ internal interface IAsyncIteratorStateMachineHolder : ICoroutineStateMachineHold
 {
     short Version { get; }
 
-    IAsyncIteratorStateMachineHolder<Nothing> CreateNewByCloningUnderlyingStateMachine(in SuspensionPoint ourSuspensionPoint, ref SuspensionPoint theirSuspensionPoint);
+    IAsyncIteratorStateMachineHolder<VoidCoroutineResult> CreateNewByCloningUnderlyingStateMachine(in SuspensionPoint ourSuspensionPoint, ref SuspensionPoint theirSuspensionPoint);
 }
 
 internal interface IAsyncIteratorStateMachineHolder<TResult> : IAsyncIteratorStateMachineHolder, ICoroutineStateMachineHolder<TResult>, IValueTaskSource<TResult>

src/Tenekon.Coroutines/Coroutines/Iterators/SuspensionPoint.cs

@@ -1,4 +1,6 @@
-namespace Tenekon.Coroutines.Iterators;
+using Tenekon.Coroutines.Sources;
+
+namespace Tenekon.Coroutines.Iterators;
 
 internal struct SuspensionPoint
 {
@@ -30,11 +32,11 @@ internal void SupplyArgument(Key argumentKey, ICallableArgument argument, ICorou
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void BeginSupplyingAwaiterCompletionNotifier(out ManualResetCoroutineCompletionSource<Nothing> externTaskCompletionNotifierSource)
+    private void BeginSupplyingAwaiterCompletionNotifier(out ManualResetCoroutineCompletionSource<VoidCoroutineResult> externTaskCompletionNotifierSource)
     {
         ThrowIfNotRequiringAwaiterCompletionNotifier(in this);
         _state = SuspensionPointState.AwaiterCompletionNotifierSupplied | (_state & ~SuspensionPointState.AwaiterCompletionNotifierRequired);
-        externTaskCompletionNotifierSource = ManualResetCoroutineCompletionSource<Nothing>.RentFromCache();
+        externTaskCompletionNotifierSource = ManualResetCoroutineCompletionSource<VoidCoroutineResult>.RentFromCache();
         _awaiterCompletionNotifier = externTaskCompletionNotifierSource.CreateValueTask();
     }