From d19f885ad9b733b8d8ee3484c164dce611ebe3cd Mon Sep 17 00:00:00 2001
From: teneko <giteroneko@gmail.com>
Date: Sun, 6 Oct 2024 11:08:41 +0100
Subject: [PATCH] feat!: renamed YieldReturn to YieldAssign and moved
 Yielders.Yield to Coroutine.Yield

BREAKING CHANGE: To better reflect that you "replace" the coroutine result of a yielder the name YieldReturn has been renamed to YieldAssign. Also moved Yielders.Yield to Coroutine.Yield to align with Task.Yield.
---
 README.md                                     | 133 ++++++++++++++----
 samples/Playground/Playground.csproj          |   3 +-
 samples/Playground/Program.cs                 |  19 ++-
 .../Coroutines/Coroutine.Yield.cs             |  14 ++
 .../Coroutines/Iterators/AsyncIterator.T.cs   |   4 +-
 .../Coroutines/Iterators/AsyncIterator.cs     |   4 +-
 .../Coroutines/Iterators/AsyncIteratorImpl.cs |   4 +-
 .../Coroutines/Iterators/IAsyncIterator.T.cs  |   4 +-
 .../Coroutines/Iterators/IAsyncIterator.cs    |   4 +-
 .../Coroutines/Yielders.Yield.cs              |   8 --
 ...eldReturn.T.cs => Yielders.YieldAssign.cs} |  22 +--
 src/Tenekon.Coroutines/Coroutines/Yielders.cs |   2 +-
 ...T.cs => AsyncIteratorTests.YieldAssign.cs} |   6 +-
 .../Iterators/AsyncIteratorTests.cs           |   4 +-
 ...Assembly_HasApprovedPublicApi.verified.txt |  22 +--
 15 files changed, 164 insertions(+), 89 deletions(-)
 create mode 100644 src/Tenekon.Coroutines/Coroutines/Coroutine.Yield.cs
 rename src/Tenekon.Coroutines/Coroutines/{Yielders.YieldReturn.T.cs => Yielders.YieldAssign.cs} (69%)
 rename test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/{AsyncIteratorTests.YieldReturn.T.cs => AsyncIteratorTests.YieldAssign.cs} (89%)

diff --git a/README.md b/README.md
index b66bfa3..9c8f602 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ dotnet add package Tenekon.Coroutines --version <type version here>
 
 ## Quick start guide
 
-**Simple Coroutine**
+**Simple Coroutine: Hello World**
 
 ```csharp
 using static Tenekon.Coroutines.Yielders;
@@ -53,7 +53,31 @@ await Func<Coroutine>(async () => {
 // Hello world
 ```
 
-**Simple AsyncIterator**
+**Advanced Coroutine: Parallelism**
+
+```csharp
+await Coroutine.Start(async () =>
+{
+    var t1 = await Coroutine.Factory.StartNew(new Func<Coroutine>(async () =>
+    {
+        Thread.Sleep(3000);
+        Console.WriteLine(DateTime.UtcNow - Process.GetCurrentProcess().StartTime.ToUniversalTime() + ": Finished");
+    }));
+
+    var t2 = await Coroutine.Factory.StartNew(new Func<Coroutine>(async () =>
+    {
+        Thread.Sleep(3000);
+        Console.WriteLine(DateTime.UtcNow - Process.GetCurrentProcess().StartTime.ToUniversalTime() + ": Finished");
+    }));
+
+    await Task.WhenAll(t1.AsTask(), t2.AsTask());
+});
+
+// 00:00:03.0317613: Finished
+// 00:00:03.0317757: Finished
+```
+
+**Simple AsyncIterator: Iterator**
 
 ```csharp
 using static Tenekon.Coroutines.Yielders;
@@ -64,16 +88,15 @@ var iterator = AsyncIterator.Create(async () => {
 });
 
 while (await iterator.MoveNextAsync()) {
-  if (iterator.CurrentKey == CallKey) {
-    Console.WriteLine(((CallArgument<string>)iterator.Current).Closure);
-  }
+  Console.WriteLine(((CallArgument<string>)iterator.Current).Closure);
 }
 
 // Outputs:
 // Hello world
+// Hello world
 ```
 
-**Advanced AsyncIterator**
+**Advanced AsyncIterator: Iterator, Replace Current**
 
 ```csharp
 using static Tenekon.Coroutines.Yielders;
@@ -84,10 +107,8 @@ var iterator = AsyncIterator.Create(async () => {
 });
 
 while (await iterator.MoveNextAsync()) {
-  if (iterator.CurrentKey == CallKey) {
-    Console.WriteLine(((CallArgument<string>)iterator.Current).Closure);
-    iterator.Current = new CallArgument<string>(Console.WriteLine, "Hello iterator")
-  }
+  Console.WriteLine(((CallArgument<string>)iterator.Current).Closure);
+  iterator.Current = new CallArgument<string>(Console.WriteLine, "Hello iterator")
 }
 
 // Outputs:
@@ -95,7 +116,7 @@ while (await iterator.MoveNextAsync()) {
 // Hello iterator
 ```
 
-**Advanced AsyncIterator**
+**Advanced AsyncIterator: Iterator, Yield Assign**
 
 ```csharp
 using static Tenekon.Coroutines.Iterator.Yielders;
@@ -106,10 +127,8 @@ var iterator = AsyncIterator.Create(async () => {
 });
 
 while (await iterator.MoveNextAsync()) {
-  if (iterator.CurrentKey == ExchangeKey) {
-    Console.WriteLine(((ExchangeArgument<string>)iterator.Current).Value);
-    iterator.YieldReturn("Hello iterator");
-  }
+  Console.WriteLine(((ExchangeArgument<string>)iterator.Current).Value);
+  iterator.YieldAssign("Hello iterator");
 }
 
 // Outputs:
@@ -123,11 +142,61 @@ Yielders are the equivalent to effects in Redux-Saga.
 
 In the following are all available `Yielders` classes and their contained yielders listed.
 
-We recommend to make use of `using static`, e.g. `using static Tenekon.Coroutines.Yielders`.
+### Tenekon.Coroutines.Coroutine
+
+The yielding components of `Coroutine` are designed to align with the functionality of `Task`.
+
+#### Tenekon.Coroutines.Coroutine.Yield
+
+Use `Yield` to instruct the coroutine to suspend and resume immediatelly. In the underlying code, `Task.Yield()` is used.
+
+| Yielder | Signature                     |
+| ------- | ----------------------------- |
+| `Yield` | `Coroutine Coroutine Yield()` |
+
+#### Tenekon.Coroutines.Coroutine.Run
+
+The `Coroutine.Run` yielder is the equivalent to `Task.Run`
+
+| Yielder         | Signature                                                                                                                                                           |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable> Run(Func<Coroutine> provider, CancellationToken cancellationToken)`                                                                  |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable> Run(Func<Coroutine> provider)`                                                                                                       |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable> Run<TClosure>(Func<TClosure, Coroutine> provider, TClosure closure, CancellationToken cancellationToken)`                            |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable> Run<TClosure>(Func<TClosure, Coroutine> provider, TClosure closure)`                                                                 |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable<TResult>> Run<TResult>(Func<Coroutine<TResult>> provider, CancellationToken cancellationToken)`                                       |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable<TResult>> Run<TResult>(Func<Coroutine<TResult>> provider)`                                                                            |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable<TResult>> Run<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure, CancellationToken cancellationToken)` |
+| `Coroutine.Run` | `Coroutine<CoroutineAwaitable<TResult>> Run<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure)`                                      |
+
+#### Tenekon.Coroutines.Coroutine.Run
+
+The `Coroutine.Factory.StartNew` yielder is the equivalent to `Task.Factory.StartNew`
+
+| Yielder                      | Signature                                                                                                                                                                                                                              |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew(Func<Coroutine> provider, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)`                                                                  |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew(Func<Coroutine> provider, CancellationToken cancellationToken)`                                                                                                                                |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew(Func<Coroutine> provider, TaskCreationOptions creationOptions)`                                                                                                                                |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew(Func<Coroutine> provider)`                                                                                                                                                                     |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew<TClosure>(Func<TClosure, Coroutine> provider, TClosure closure, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)`                            |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew<TClosure>(Func<TClosure, Coroutine> provider, TClosure closure, CancellationToken cancellationToken)`                                                                                          |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew<TClosure>(Func<TClosure, Coroutine> provider, TClosure closure, TaskCreationOptions creationOptions)`                                                                                          |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable> StartNew<TClosure>(Func<TClosure, Coroutine> provider, TClosure closure)`                                                                                                                               |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TResult>(Func<Coroutine<TResult>> provider, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)`                                       |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TResult>(Func<Coroutine<TResult>> provider, CancellationToken cancellationToken)`                                                                                                     |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TResult>(Func<Coroutine<TResult>> provider, TaskCreationOptions creationOptions)`                                                                                                     |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TResult>(Func<Coroutine<TResult>> provider)`                                                                                                                                          |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)` |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure, CancellationToken cancellationToken)`                                                               |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure, TaskCreationOptions creationOptions)`                                                               |
+| `Coroutine.Factory.StartNew` | `Coroutine<CoroutineAwaitable<TResult>> StartNew<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure)`                                                                                                    |
 
 ### Tenekon.Coroutines.Yielders
 
-#### Call
+We recommend to make use of `using static`, e.g. `using static Tenekon.Coroutines.Yielders`.
+
+#### Tenekon.Coroutines.Yielders.Call
 
 The `Call` yielder is the equivalent to the `call` effect in Redux-Saga.
 
@@ -140,7 +209,7 @@ Use it to instruct the coroutine to suspend and invoke `provider` with optional
 | `Call`  | `Coroutine<TResult> Call<TResult>(Func<Coroutine<TResult>> provider)`                                       |
 | `Call`  | `Coroutine<TResult> Call<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure)` |
 
-#### Launch
+#### Tenekon.Coroutines.Yielders.Launch
 
 The `Launch` yielder is the equivalent to the `fork` effect in Redux-Saga.
 
@@ -153,7 +222,7 @@ Use it to instruct the coroutine to suspend and invoke `provider` with optional
 | `Launch` | `Coroutine<CoroutineAwaitable<TResult>> Launch<TResult>(Func<Coroutine<TResult>> provider)`                                       |
 | `Launch` | `Coroutine<CoroutineAwaitable<TResult>> Launch<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure)` |
 
-#### Spawn
+#### Tenekon.Coroutines.Yielders.Spawn
 
 The `Spawn` yielder is the equivalent to the `spawn` effect in Redux-Saga.
 
@@ -166,7 +235,7 @@ Use it to instruct the coroutine to suspend and invoke `provider` with optional
 | `Spawn` | `Coroutine<CoroutineAwaitable<TResult>> Spawn<TResult>(Func<Coroutine<TResult>> provider)`                                       |
 | `Spawn` | `Coroutine<CoroutineAwaitable<TResult>> Spawn<TClosure, TResult>(Func<TClosure, Coroutine<TResult>> provider, TClosure closure)` |
 
-#### Spawn
+#### Tenekon.Coroutines.Yielders.Spawn
 
 Use `Throw` to instruct the coroutine to suspend and let the coroutine throw `exception`. The coroutine resumes immediatelly and throws `excpetion`.
 
@@ -174,7 +243,7 @@ Use `Throw` to instruct the coroutine to suspend and let the coroutine throw `ex
 | ------- | -------------------------------------- |
 | `Throw` | `Coroutine Throw(Exception exception)` |
 
-#### WithContext
+#### Tenekon.Coroutines.Yielders.WithContext
 
 Use `WithContext` to instruct the coroutine to suspend and invoke `provider` with `additiveContext` and optional `closure`.
 
@@ -185,15 +254,7 @@ Use `WithContext` to instruct the coroutine to suspend and invoke `provider` wit
 | `WithContext` | `Coroutine<TResult> WithContext<TResult>(CoroutineContext additiveContext, Func<Coroutine<TResult>> provider)`                                       |
 | `WithContext` | `Coroutine<TResult> WithContext<TClosure, TResult>(CoroutineContext additiveContext, Func<TClosure, Coroutine<TResult>> provider, TClosure closure)` |
 
-#### Yield
-
-Use `Yield` to instruct the coroutine to suspend and resume immediatelly. In the underlying is `Task.Yield()` used.
-
-| Yielder | Signature                     |
-| ------- | ----------------------------- |
-| `Yield` | `Coroutine Coroutine Yield()` |
-
-#### YieldReturn
+#### Tenekon.Coroutines.Yielders.YieldReturn
 
 Use `YieldReturn` to instruct the coroutine to suspend and resume immediatelly. Allows the coroutine middleware to get the hands on `value`.
 
@@ -201,7 +262,17 @@ Use `YieldReturn` to instruct the coroutine to suspend and resume immediatelly.
 | ------------- | ----------------------------------- |
 | `YieldReturn` | `Coroutine YieldReturn<T>(T value)` |
 
-## Tenekon.Coroutines.Iterators.Yielders
+#### Tenekon.Coroutines.Yielders.YieldAssign
+
+Use `YieldAssign` to instruct the coroutine to suspend and resume immediatelly.
+Allows the coroutine middleware to get the hands on `value` and also to yield assign a custom value of type `TAssign`.
+If you do not yield assign a custom value of type `TAssign`, then `default(TAssign)` is yield assigned.
+
+| Yielder       | Signature                                                                                        |
+| ------------- | ------------------------------------------------------------------------------------------------ |
+| `YieldAssign` | `YieldAssign<TYield> Yield<TYield>(TYield value) => new(value)` -> `Coroutine<TAssign> Assign<TAssign>()` |
+
+## Tenekon.Coroutines.Yielders.Exchange
 
 Use `Exchange` to instruct the coroutine to suspend and resume immediatelly. Allows the coroutine middleware to get the hands on `value` and exchange it.
 
diff --git a/samples/Playground/Playground.csproj b/samples/Playground/Playground.csproj
index 7e0305d..d00b746 100644
--- a/samples/Playground/Playground.csproj
+++ b/samples/Playground/Playground.csproj
@@ -2,9 +2,10 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+		<PublishAot>true</PublishAot>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/samples/Playground/Program.cs b/samples/Playground/Program.cs
index d7adf35..736a72f 100644
--- a/samples/Playground/Program.cs
+++ b/samples/Playground/Program.cs
@@ -1,22 +1,19 @@
-using Tenekon.Coroutines;
+using System.Diagnostics;
+using Tenekon.Coroutines;
 
 await Coroutine.Start(async () =>
 {
-    Console.WriteLine(Environment.CurrentManagedThreadId);
-
-    var t1 = await Coroutine.Factory.StartNew(async () =>
+    var t1 = await Coroutine.Factory.StartNew(new Func<Coroutine>(async () =>
     {
-        Console.WriteLine("Hello World " + Environment.CurrentManagedThreadId);
         Thread.Sleep(3000);
-        Console.WriteLine("Finished");
-    });
+        Console.WriteLine(DateTime.UtcNow - Process.GetCurrentProcess().StartTime.ToUniversalTime() + ": Finished");
+    }));
 
-    var t2 = await Coroutine.Factory.StartNew(async () =>
+    var t2 = await Coroutine.Factory.StartNew(new Func<Coroutine>(async () =>
     {
-        Console.WriteLine("Hello World " + Environment.CurrentManagedThreadId);
         Thread.Sleep(3000);
-        Console.WriteLine("Finished");
-    });
+        Console.WriteLine(DateTime.UtcNow - Process.GetCurrentProcess().StartTime.ToUniversalTime() + ": Finished");
+    }));
 
     await Task.WhenAll(t1.AsTask(), t2.AsTask());
 });
\ No newline at end of file
diff --git a/src/Tenekon.Coroutines/Coroutines/Coroutine.Yield.cs b/src/Tenekon.Coroutines/Coroutines/Coroutine.Yield.cs
new file mode 100644
index 0000000..3b8a56d
--- /dev/null
+++ b/src/Tenekon.Coroutines/Coroutines/Coroutine.Yield.cs
@@ -0,0 +1,14 @@
+using Tenekon.Coroutines.Sources;
+using static Tenekon.Coroutines.Yielders.Arguments;
+
+namespace Tenekon.Coroutines;
+
+partial struct Coroutine
+{
+    public static Coroutine Yield()
+    {
+        var completionSource = ManualResetCoroutineCompletionSource<VoidCoroutineResult>.RentFromCache();
+        var argument = new YieldArgument(completionSource);
+        return new(completionSource, argument);
+    }
+}
diff --git a/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.T.cs b/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.T.cs
index b6d879e..d9ee7d5 100644
--- a/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.T.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.T.cs
@@ -10,9 +10,9 @@ partial class AsyncIteratorImpl<TResult>
 
     ValueTask<bool> IAsyncIterator<TResult>.MoveNextAsync() => MoveNextAsync();
 
-    void IAsyncIterator<TResult>.YieldReturn<TYieldResult>(TYieldResult result) => YieldReturn(result);
+    void IAsyncIterator<TResult>.YieldAssign<TYieldResult>(TYieldResult result) => YieldAssign(result);
 
-    void IAsyncIterator<TResult>.YieldReturn() => YieldReturn();
+    void IAsyncIterator<TResult>.YieldAssign() => YieldAssign();
 
     void IAsyncIterator<TResult>.Return(TResult result) => Return(result);
 
diff --git a/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.cs b/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.cs
index 87bbe3b..85582b4 100644
--- a/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIterator.cs
@@ -29,9 +29,9 @@ partial class AsyncIteratorImpl<TResult>
 
     ValueTask<bool> IAsyncIterator.MoveNextAsync() => MoveNextAsync();
 
-    void IAsyncIterator.YieldReturn<TYieldResult>(TYieldResult result) => YieldReturn(result);
+    void IAsyncIterator.YieldAssign<TYieldResult>(TYieldResult result) => YieldAssign(result);
 
-    void IAsyncIterator.YieldReturn() => YieldReturn();
+    void IAsyncIterator.YieldAssign() => YieldAssign();
 
     void IAsyncIterator.Return() => Return(default!);
 
diff --git a/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIteratorImpl.cs b/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIteratorImpl.cs
index c9a0fe5..2bb4b98 100644
--- a/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIteratorImpl.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Iterators/AsyncIteratorImpl.cs
@@ -200,7 +200,7 @@ public async ValueTask<bool> MoveNextAsync()
         return false;
     }
 
-    public void YieldReturn<TYieldResult>(TYieldResult result)
+    public void YieldAssign<TYieldResult>(TYieldResult result)
     {
         if (_nextSuspensionPoint._state != 0) {
             try {
@@ -220,7 +220,7 @@ public void YieldReturn<TYieldResult>(TYieldResult result)
         }
     }
 
-    public void YieldReturn()
+    public void YieldAssign()
     {
         if (_nextSuspensionPoint._state != 0) {
             try {
diff --git a/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.T.cs b/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.T.cs
index 57ebbb0..338a709 100644
--- a/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.T.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.T.cs
@@ -20,9 +20,9 @@ public interface IAsyncIterator<TResult>
     /// <returns></returns>
     ValueTask<bool> MoveNextAsync();
 
-    void YieldReturn<TYieldResult>(TYieldResult result);
+    void YieldAssign<TYieldResult>(TYieldResult result);
 
-    void YieldReturn();
+    void YieldAssign();
 
     void Return(TResult result);
 
diff --git a/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.cs b/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.cs
index 906bd31..68fbbb7 100644
--- a/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Iterators/IAsyncIterator.cs
@@ -20,9 +20,9 @@ public interface IAsyncIterator
     /// <returns></returns>
     ValueTask<bool> MoveNextAsync();
 
-    void YieldReturn<TYieldResult>(TYieldResult result);
+    void YieldAssign<TYieldResult>(TYieldResult result);
 
-    void YieldReturn();
+    void YieldAssign();
 
     void Return();
 
diff --git a/src/Tenekon.Coroutines/Coroutines/Yielders.Yield.cs b/src/Tenekon.Coroutines/Coroutines/Yielders.Yield.cs
index c36d8d1..9c41a31 100644
--- a/src/Tenekon.Coroutines/Coroutines/Yielders.Yield.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Yielders.Yield.cs
@@ -1,17 +1,9 @@
 using Tenekon.Coroutines.Sources;
-using static Tenekon.Coroutines.Yielders.Arguments;
 
 namespace Tenekon.Coroutines;
 
 partial class Yielders
 {
-    public static Coroutine Yield()
-    {
-        var completionSource = ManualResetCoroutineCompletionSource<VoidCoroutineResult>.RentFromCache();
-        var argument = new YieldArgument(completionSource);
-        return new(completionSource, argument);
-    }
-
     partial class Arguments
     {
         public class YieldArgument : ICallableArgument<ManualResetCoroutineCompletionSource<VoidCoroutineResult>>, ISiblingCoroutine
diff --git a/src/Tenekon.Coroutines/Coroutines/Yielders.YieldReturn.T.cs b/src/Tenekon.Coroutines/Coroutines/Yielders.YieldAssign.cs
similarity index 69%
rename from src/Tenekon.Coroutines/Coroutines/Yielders.YieldReturn.T.cs
rename to src/Tenekon.Coroutines/Coroutines/Yielders.YieldAssign.cs
index c37aaf7..95c7b9f 100644
--- a/src/Tenekon.Coroutines/Coroutines/Yielders.YieldReturn.T.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Yielders.YieldAssign.cs
@@ -5,17 +5,17 @@ namespace Tenekon.Coroutines;
 
 partial class Yielders
 {
-    public readonly struct YieldReturnQuery<TYield>(TYield value)
+    public readonly struct YieldAssign<TYield>(TYield value)
     {
-        public readonly Coroutine<TReturn> Return<TReturn>()
+        public readonly Coroutine<TAssign> Assign<TAssign>()
         {
-            var completionSource = ManualResetCoroutineCompletionSource<TReturn>.RentFromCache();
-            var argument = new YieldReturnArgument<TYield, TReturn>(value, completionSource);
+            var completionSource = ManualResetCoroutineCompletionSource<TAssign>.RentFromCache();
+            var argument = new YieldReturnArgument<TYield, TAssign>(value, completionSource);
             return new(completionSource, argument);
         }
     }
 
-    public static YieldReturnQuery<TValue> Yield<TValue>(TValue value) => new(value);
+    public static YieldAssign<TYield> Yield<TYield>(TYield value) => new(value);
 
     partial class Arguments
     {
@@ -33,9 +33,9 @@ internal readonly struct YieldReturnArgumentCore<TYield, TReturn>(TYield value,
             public readonly override int GetHashCode() => HashCode.Combine(Value);
         }
 
-        public class YieldReturnArgument<TYield, TReturn> : ICallableArgument<ManualResetCoroutineCompletionSource<TReturn>>, ISiblingCoroutine
+        public class YieldReturnArgument<TYield, TAssign> : ICallableArgument<ManualResetCoroutineCompletionSource<TAssign>>, ISiblingCoroutine
         {
-            private readonly YieldReturnArgumentCore<TYield, TReturn> _core;
+            private readonly YieldReturnArgumentCore<TYield, TAssign> _core;
 
             public TYield Value {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -43,16 +43,16 @@ public TYield Value {
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal YieldReturnArgument(TYield value, ManualResetCoroutineCompletionSource<TReturn> completionSource) => _core = new(value, completionSource);
+            internal YieldReturnArgument(TYield value, ManualResetCoroutineCompletionSource<TAssign> completionSource) => _core = new(value, completionSource);
 
             public YieldReturnArgument(TYield value) => _core = new(value, completionSource: null);
 
-            void ICallableArgument<ManualResetCoroutineCompletionSource<TReturn>>.Callback(in CoroutineContext context, ManualResetCoroutineCompletionSource<TReturn> completionSource) =>
+            void ICallableArgument<ManualResetCoroutineCompletionSource<TAssign>>.Callback(in CoroutineContext context, ManualResetCoroutineCompletionSource<TAssign> completionSource) =>
                 completionSource.SetDefaultResult();
 
-            void ISiblingCoroutine.ActOnCoroutine(ref CoroutineArgumentReceiver argumentReceiver) => ActOnCoroutine(ref argumentReceiver, YieldReturnVariantKey, this, _core._completionSource);
+            void ISiblingCoroutine.ActOnCoroutine(ref CoroutineArgumentReceiver argumentReceiver) => ActOnCoroutine(ref argumentReceiver, YieldAssign, this, _core._completionSource);
 
-            public override bool Equals([AllowNull] object obj) => obj is YieldReturnArgument<TYield, TReturn> other && _core.Equals(other._core);
+            public override bool Equals([AllowNull] object obj) => obj is YieldReturnArgument<TYield, TAssign> other && _core.Equals(other._core);
 
             public override int GetHashCode() => _core.GetHashCode();
         }
diff --git a/src/Tenekon.Coroutines/Coroutines/Yielders.cs b/src/Tenekon.Coroutines/Coroutines/Yielders.cs
index 137a7ff..0c90177 100644
--- a/src/Tenekon.Coroutines/Coroutines/Yielders.cs
+++ b/src/Tenekon.Coroutines/Coroutines/Yielders.cs
@@ -33,7 +33,7 @@ public partial class Arguments
         public readonly static Key ThrowKey = new(s_scope, 6);
         public readonly static Key YieldKey = new(s_scope, 7);
         public readonly static Key ExchangeKey = new(s_scope, 8);
-        public readonly static Key YieldReturnVariantKey = new(s_scope, 9);
+        public readonly static Key YieldAssign = new(s_scope, 9);
         public readonly static Key StartNewKey = new(s_scope, 10);
         public readonly static Key RunKey = new(s_scope, 11);
 
diff --git a/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.YieldReturn.T.cs b/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.YieldAssign.cs
similarity index 89%
rename from test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.YieldReturn.T.cs
rename to test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.YieldAssign.cs
index c9ba01a..03cac84 100644
--- a/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.YieldReturn.T.cs
+++ b/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.YieldAssign.cs
@@ -2,13 +2,13 @@
 
 partial class AsyncIteratorTests
 {
-    public class YieldReturnVariant
+    public class YieldAssign
     {
         public class SyncCoroutineWithSyncResult : AbstractSyncCoroutineWithSyncResult<int, int>
         {
             public override int ExpectedResult => 0;
 
-            protected override Coroutine<int> CreateCoroutine() => Yield(int.MaxValue).Return<int>();
+            protected override Coroutine<int> CreateCoroutine() => Yield(int.MaxValue).Assign<int>();
             protected override ValueTask<int> Unwrap(int resultWrapper) => new(resultWrapper);
             protected override ValueTask<Coroutine<int>> Unwrap(Coroutine<int> coroutine) => new(coroutine);
         }
@@ -19,7 +19,7 @@ public class AsyncCoroutineWithSyncResult : AbstractAsyncCoroutineWithSyncResult
             public override int ExpectedYieldResult => Two;
             public override int ExpectedYieldResultOfClone => 0;
 
-            protected override async Coroutine<int> CreateCoroutine() => await Yield(int.MaxValue).Return<int>();
+            protected override async Coroutine<int> CreateCoroutine() => await Yield(int.MaxValue).Assign<int>();
             protected override ValueTask<int> Unwrap(int resultWrapper) => new(resultWrapper);
             protected override ValueTask<Coroutine<int>> Unwrap(Coroutine<int> coroutine) => new(coroutine);
         }
diff --git a/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.cs b/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.cs
index ca298e5..fc8f0ac 100644
--- a/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.cs
+++ b/test/Tenekon.Coroutines.NetTest/Coroutines/Iterators/AsyncIteratorTests.cs
@@ -83,7 +83,7 @@ public virtual async Task MoveNextThenYieldReturnThenGetResult_Returns()
         {
             var iterator = CreateCoroutine().GetAsyncIterator();
             _ = await iterator.MoveNextAsync();
-            iterator.YieldReturn(ExpectedYieldResult);
+            iterator.YieldAssign(ExpectedYieldResult);
             var asyncResult = await iterator.GetResultAsync();
             var result = await Unwrap(asyncResult);
             result.Should().Be(await Unwrap(ExpectedYieldResult));
@@ -125,7 +125,7 @@ public virtual async Task Clone_DoesNotConsumesOriginalIterator()
             _ = await our.MoveNextAsync();
             var their = our.Clone();
             _ = await their.MoveNextAsync();
-            their.YieldReturn(ExpectedYieldResultOfClone);
+            their.YieldAssign(ExpectedYieldResultOfClone);
             var ourAsyncResult = await our.GetResultAsync();
             var ourResult = await Unwrap(ourAsyncResult);
             var theirAsyncResult = await their.GetResultAsync();
diff --git a/test/Tenekon.Coroutines.NetTest/Coroutines/PublicApiTests.CoroutinesNetAssembly_HasApprovedPublicApi.verified.txt b/test/Tenekon.Coroutines.NetTest/Coroutines/PublicApiTests.CoroutinesNetAssembly_HasApprovedPublicApi.verified.txt
index 47ba391..e79746a 100644
--- a/test/Tenekon.Coroutines.NetTest/Coroutines/PublicApiTests.CoroutinesNetAssembly_HasApprovedPublicApi.verified.txt
+++ b/test/Tenekon.Coroutines.NetTest/Coroutines/PublicApiTests.CoroutinesNetAssembly_HasApprovedPublicApi.verified.txt
@@ -75,6 +75,7 @@ namespace Tenekon.Coroutines
         public static Tenekon.Coroutines.CompilerServices.CoroutineAwaitable<TResult> Start<TResult>(System.Func<Tenekon.Coroutines.Coroutine<TResult>> provider, Tenekon.Coroutines.CoroutineContext context = default) { }
         public static Tenekon.Coroutines.CompilerServices.CoroutineAwaitable Start<TClosure>(System.Func<TClosure, Tenekon.Coroutines.Coroutine> provider, TClosure closure, Tenekon.Coroutines.CoroutineContext context = default) { }
         public static Tenekon.Coroutines.CompilerServices.CoroutineAwaitable<TResult> Start<TClosure, TResult>(System.Func<TClosure, Tenekon.Coroutines.Coroutine<TResult>> provider, TClosure closure, Tenekon.Coroutines.CoroutineContext context = default) { }
+        public static Tenekon.Coroutines.Coroutine Yield() { }
         public static Tenekon.Coroutines.Coroutine op_Implicit(System.Threading.Tasks.Task task) { }
         public static Tenekon.Coroutines.Coroutine op_Implicit(System.Threading.Tasks.ValueTask task) { }
         public static bool operator !=(Tenekon.Coroutines.Coroutine left, Tenekon.Coroutines.Coroutine right) { }
@@ -287,8 +288,7 @@ namespace Tenekon.Coroutines
         public static Tenekon.Coroutines.Coroutine<TResult> WithContext<TResult>(in Tenekon.Coroutines.CoroutineContext additiveContext, Tenekon.Coroutines.CoroutineProviderDelegate<TResult> provider) { }
         public static Tenekon.Coroutines.Coroutine WithContext<TClosure>(in Tenekon.Coroutines.CoroutineContext additiveContext, Tenekon.Coroutines.CoroutineProviderWithClosureDelegate<TClosure> provider, TClosure closure) { }
         public static Tenekon.Coroutines.Coroutine<TResult> WithContext<TClosure, TResult>(in Tenekon.Coroutines.CoroutineContext additiveContext, Tenekon.Coroutines.CoroutineProviderWithClosureDelegate<TClosure, TResult> provider, TClosure closure) { }
-        public static Tenekon.Coroutines.Coroutine Yield() { }
-        public static Tenekon.Coroutines.Yielders.YieldReturnQuery<TValue> Yield<TValue>(TValue value) { }
+        public static Tenekon.Coroutines.Yielders.YieldAssign<TYield> Yield<TYield>(TYield value) { }
         public static Tenekon.Coroutines.Coroutine YieldReturn<T>(T value) { }
         public class Arguments
         {
@@ -300,9 +300,9 @@ namespace Tenekon.Coroutines
             public static readonly Tenekon.Coroutines.Key StartNewKey;
             public static readonly Tenekon.Coroutines.Key ThrowKey;
             public static readonly Tenekon.Coroutines.Key WithContextKey;
+            public static readonly Tenekon.Coroutines.Key YieldAssign;
             public static readonly Tenekon.Coroutines.Key YieldKey;
             public static readonly Tenekon.Coroutines.Key YieldReturnKey;
-            public static readonly Tenekon.Coroutines.Key YieldReturnVariantKey;
             public Arguments() { }
             public class CallArgument<TClosure> : Tenekon.Coroutines.ICallableArgument, Tenekon.Coroutines.ICallableArgument<Tenekon.Coroutines.Sources.ManualResetCoroutineCompletionSource<Tenekon.Coroutines.VoidCoroutineResult>>, Tenekon.Coroutines.ISiblingCoroutine
             {
@@ -458,7 +458,7 @@ namespace Tenekon.Coroutines
                 public override bool Equals([System.Diagnostics.CodeAnalysis.AllowNull] object obj) { }
                 public override int GetHashCode() { }
             }
-            public class YieldReturnArgument<TYield, TReturn> : Tenekon.Coroutines.ICallableArgument, Tenekon.Coroutines.ICallableArgument<Tenekon.Coroutines.Sources.ManualResetCoroutineCompletionSource<TReturn>>, Tenekon.Coroutines.ISiblingCoroutine
+            public class YieldReturnArgument<TYield, TAssign> : Tenekon.Coroutines.ICallableArgument, Tenekon.Coroutines.ICallableArgument<Tenekon.Coroutines.Sources.ManualResetCoroutineCompletionSource<TAssign>>, Tenekon.Coroutines.ISiblingCoroutine
             {
                 public YieldReturnArgument(TYield value) { }
                 public TYield Value { get; }
@@ -466,10 +466,10 @@ namespace Tenekon.Coroutines
                 public override int GetHashCode() { }
             }
         }
-        public readonly struct YieldReturnQuery<TYield>
+        public readonly struct YieldAssign<TYield>
         {
-            public YieldReturnQuery(TYield value) { }
-            public Tenekon.Coroutines.Coroutine<TReturn> Return<TReturn>() { }
+            public YieldAssign(TYield value) { }
+            public Tenekon.Coroutines.Coroutine<TAssign> Assign<TAssign>() { }
         }
     }
 }
@@ -548,8 +548,8 @@ namespace Tenekon.Coroutines.Iterators
         System.Threading.Tasks.ValueTask<bool> MoveNextAsync();
         void Return();
         void Throw(System.Exception e);
-        void YieldReturn();
-        void YieldReturn<TYieldResult>(TYieldResult result);
+        void YieldAssign();
+        void YieldAssign<TYieldResult>(TYieldResult result);
     }
     public interface IAsyncIterator<TResult>
     {
@@ -562,8 +562,8 @@ namespace Tenekon.Coroutines.Iterators
         System.Threading.Tasks.ValueTask<bool> MoveNextAsync();
         void Return(TResult result);
         void Throw(System.Exception e);
-        void YieldReturn();
-        void YieldReturn<TYieldResult>(TYieldResult result);
+        void YieldAssign();
+        void YieldAssign<TYieldResult>(TYieldResult result);
     }
     [System.Flags]
     public enum SuspensionPointState