CoRoutine -> A regular coroutine that can return any value (or void)
CoGenerator -> A regular generator type function.

- The classes provided with the package expose "traditional" Upp-like interface (Do(), Get(), Pick() and Next() -methods, depending on their type.) 

- Allows exception handling and propagation.

- Also an example code is included.

#include <Core/Core.h>
#include "CoRoutine.h"

using namespace Upp;

CoRoutine<Vector<int>> CoMakeIota(int begin, int end, int step)
{
	Vector<int> v;
	for(int i = begin; i < end; i += step) {
		v.Add(i);
		RLOG(__func__);
		co_await CoSuspend();
	}
	co_return v;
}

CoGenerator<int> CoGenerateNumbers()
{
	int i = 0;
	for(;;) {
		RLOG(__func__);
		co_yield i++;
	}
}

CONSOLE_APP_MAIN
{
	StdLogSetup(LOG_COUT|LOG_FILE);

	auto co1 = CoMakeIota(0, 10, 2);
	auto co2 = CoGenerateNumbers();
	
	try {
		while(co1.Do())
			RLOG(__func__); // NOP;
		auto v = co1.Pick();
		RDUMP(v);
		
		for(int i = 0; i < 10; i = co2.Next())
			RDUMP(i);
	}
    catch(...) {
        RLOG("Unhandled exception");
    }

}

CONSOLE_APP_MAIN
{
	StdLogSetup(LOG_COUT|LOG_FILE);

	auto generator = []() -> CoGenerator<int> {
		for(int i = 0;; i++)
			co_yield i;
	};
	
	for(auto i : generator()) {
		RLOG(i);
		if(i == 100)
			break;
	}
	
	for(auto i :[]() -> CoGenerator<int> { int i = 0; while(true) co_yield i++; }()) {
		RLOG(i);
		if(i == 100)
			break;
	}
}

A coroutine is a function that can suspend execution to be resumed later. Coroutines are stackless: they suspend execution by returning to the caller and the data that is required to resume execution is stored separately from the stack. This allows for sequential code that executes asynchronously (e.g. to handle non-blocking I/O without explicit callbacks), and also supports algorithms on lazy-computed infinite sequences and other uses. 

#include <CtrlLib/CtrlLib.h>
#include <CoRoutines/CoRoutines.h>


// GuiWebDownloader example, adapted to coroutines.

using namespace Upp;


CoRoutine<void> HttpDownload(const String& url)
{
	Progress pi;
	String path = AppendFileName(Nvl(GetDownloadFolder(), GetHomeDirFile("downloads")), GetFileName(url));
	HttpRequest http(url);
	http.Timeout(0);
	int loaded = 0;
	{
		FileOut out(path);
		http.WhenContent = [&out, &loaded](const void *ptr, int size) { out.Put(ptr, size); loaded += size; };
		while(http.Do()) {
			if(http.GetContentLength() >= 0) {
				pi.SetText("Downloading " + GetFileName(url));
				pi.Set((int)loaded, (int)http.GetContentLength());
			}
			else {
				pi.Set(0, 0);
				pi.SetText(http.GetPhaseName());
			}
			if(pi.Canceled())
				http.Abort();
			else
				co_await CoSuspend();
		}
	}
	if(http.IsFailure()) {
		DeleteFile(path);
		Exclamation("Download has failed.&\1" +
			(http.IsError()
				? http.GetErrorDesc()
					: AsString(http.GetStatusCode()) + ' ' + http.GetReasonPhrase()));
	}
}

GUI_APP_MAIN
{
	StdLogSetup(LOG_COUT|LOG_FILE);
	
	String url = "http://downloads.sourceforge.net/project/upp/upp/4179/upp-x11-src-4179.tar.gz";

	for(;;) {
		if(!EditText(url, "Download", "URL"))
			return;
		auto downloader = HttpDownload(url); // Multiple downloaders can be created/run at once.
		try
		{
			while(downloader.Do())
				Sleep(1); // Simulate work.
		}
		catch(const Exc& e)
		{
			
		}
		catch(...)
		{
			
		}
	}
}