CppStandard = CppStandardVersion.Cpp20;

PCHUsage = PCHUsageMode.NoSharedPCHs;
PrivatePCHHeaderFile = "YourPCH.h";

using namespace UE5Coro;

TGenerator<int> CountToThree()
{
    for (int i = 1; i <= 3; ++i)
        co_yield i;
}

TGenerator<int> G1 = CountToThree(); // Runs to co_yield i; with i==1
do
{
    // This check can be omitted if you're guaranteed at least one
    // co_yield from the generator.
    if (G1)
        int Value = G1.Current();

    // Resume() continues the function until the next co_yield or until
    // control leaves scope. As a convenience it returns operator bool().
} while (G1.Resume());

TGenerator<int> G2 = CountToThree();
for (auto It = G2.CreateIterator(); It; ++It)
    int Value = *It;

TGenerator<int> G3 = CountToThree();
for (int Value : G3)
    DoSomethingWith(Value);

TGenerator 
   Every64BitPrime()
{
    
   // You probably don't want to run this on tick...
    
   for (uint64 i = 
   2; i <= UINT64_MAX; ++i)
        
   if (
   IsPrime(i))
            
   co_yield i;
}

TGenerator
   
     Primes = Every64BitPrime();
uint64 Two = Primes.Current();
Primes.Resume();
uint64 Three = Primes.Current();
Primes.Resume();
uint64 Five = Primes.Current();

    // Done! Primes going out of scope will destroy the coroutine.
   
  

AllTheParkingSpaces = InfiniteString(); for (int i = 0; i < 10; ++i) { TCHAR P = AllTheParkingSpaces.Current(); AllTheParkingSpaces.Resume(); }">

TGenerator 
   InfiniteString()
{
    
   // Warranty void on integer overflow
    
   for (
   int i = 
   1; 
   /*forever*/; ++i)
    {
        
   UE_LOG(LogTemp, Display, 
   TEXT(
   "%d parking space(s) served.", i);
        
   co_yield 
   TEXT(
   '🅿️');
    }
}


   // Only 10 needed for the company fleet
TGenerator
   
     AllTheParkingSpaces = InfiniteString();

    for (
    int i = 
    0; i < 
    10; ++i)
{
    TCHAR P = AllTheParkingSpaces.
    Current();
    AllTheParkingSpaces.
    Resume();
}
   
  

FLatentCoroutine to your lambda to make it coroutine enabled! FLatentCoroutine::Start(LatentInfo, []() -> FLatentCoroutine { // You're now in the next tick. co_await Latent::Ticks(10); // An additional 10 ticks later... co_await Latent::Seconds(1.0f); // 1 second later, regardless of FPS... // As you return from this lambda, your BP node will fire its // latent exec pin. }); }">

// .h
UFUNCTION(BlueprintCallable, Meta = (Latent, LatentInfo = "LatentInfo"))
static void Foo(int EpicPleaseFixUE22342, FLatentActionInfo LatentInfo);

// .cpp
using namespace UE5Coro;

void UExampleFunctionLibrary::Foo(int, FLatentActionInfo LatentInfo)
{
    // Add -> FLatentCoroutine to your lambda to make it coroutine enabled!
    FLatentCoroutine::Start(LatentInfo, []() -> FLatentCoroutine
    {
        // You're now in the next tick.
        co_await Latent::Ticks(10);
        // An additional 10 ticks later...
        co_await Latent::Seconds(1.0f);
        // 1 second later, regardless of FPS...

        // As you return from this lambda, your BP node will fire its
        // latent exec pin.
    });
}

using namespace UE5Coro;

AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, []() -> FAsyncCoroutine)
{
    // You're now in the thread that was given to AsyncTask.
    DoExpensiveThing();
    co_await Async::MoveToThread(ENamedThreads::GameThread);
    // You're now on the game thread!
    co_await Async::MoveToThread(ENamedThreads::AnyHiPriThreadHiPriTask);
    // You can move in and out as you wish.
    if (bShouldSwitchThreadsAgain)
        co_await Async::MoveToThread(ENamedThreads::GameThread);
    // Runtime-decided thread!
});

// No need to start with AsyncTask:
FAsyncCoroutine DoBackgroundThing()
{
    // This part works just like any regular function call.
    // You're in your caller's thread.

    co_await Async::MoveToThread(ENamedThreads::AnyBackgroundThreadNormalTask);
    // You're now in an AsyncTask()

    co_await Async::MoveToThread(ENamedThreads::GameThread);
    // You're back on the game thread in another AsyncTask()
}

// Use like this, the return value does not need to be stored:
DoBackgroundThing();

FAsyncCoroutine DontDoThisAtHome()
{
    UObject* Obj = NewObject
   ();

    
   co_await 
   Async::MoveToThread(ENamedThreads::AnyBackgroundThreadNormalTask);
    
   // You're no longer synchronously running on the game thread,
    
   // Obj *IS* eligible for garbage collection!

    
   co_await 
   Async::MoveToThread(ENamedThreads::GameThread);
    
   // You're back on the game thread, but Obj could be a dangling
    
   // pointer by now. Use TStrongObjectPtr or another method of keeping
    
   // UObjects alive if you find yourself in this scenario.
}