Feature: `doRender(..)`

[getify]

This is a fancy, reactive string builder. It's used to define "components" as do-routines that yield string(s) which are all concated together to produce a chunk of HTML, which can then be shoved into the DOM. Since it's based on IOx, it can be set as dependent on other IOs/IOxs as inputs and reactively re-rendered on each update.

Example for how to use the utility:

// this could be an IOx which can have its value updated
// over time if desired 
var id = IO.of(42);

doRender(whatever,[ id ])

// this step is just console.log()ing, but it could instead
// be pushing the HTML into a DOM element
.map(v => console.log("html",v))

.run({});

// here's a "component" -- you `yield` out string(s), or any
// monad that produces a string, and it concats them all.
//
// the nice thing is, other than the string concating, this
// is a full do-routine that can be async, do any monad/IO
// operations, etc, whatever you need to define your
// component's markup
function *whatever(context,id) {
	yield `<div id="${id}">`;
	for (let i = 0; i < 3; i++) {
		yield `<span>${i}</span>`;
	}
	yield `</div>`;
}

And here's the candidate first implementation of doRender(..):

function doRender(gen,deps = [],...args) {
	return IOx.do(runner,deps);

	// ************************************
	
	async function *runner(context,...depsVals) {
		var htmlIO = IO.of("");
		
		var it = gen(context,...depsVals,...args);
		var res;
		while (true) {
			res = it.next(res);
			if (isPromise(res)) {
				res = await res;
			}
			else {
				let done = res.done;
				
				if (isMonad(res.value)) {
					if (IO.is(res.value)) {
						res = res.value.chain(concatIfString);
					}
					else if (Nothing.is(res.value)) {
						return IO.of("");
					}
					else if (Either.is(res.value) || Maybe.is(res.value)) {
						res = res.value.fold(IO.of,concatIfString);
					}
					else {
						res = res.value.fold(concatIfString);
					}
				}
				else {
					res = concatIfString(res.value);
				}

				res = yield res;
				if (done) {
					return htmlIO.run(context);
				}
			}
		}
		
		// ************************************
		
		function concatIfString(v) {
			if (typeof v == "string") {
				htmlIO = htmlIO.concat(IO.of(v));
				return IO.of();
			}
			else {
				return IO.of(v);
			}
		}
	}
}

[getify]

OK, so at @DrBoolean's sage observation, this can be generalized to support any monoid (not just strings) without too much complexity:

var id = IO.of(42);

doBuilder(whatever,v => (typeof v == "string"),[ id ])
.map(v => console.log("html",v))
.run({});

function *whatever(context,id) {
	yield `<div id="${id}">`;
	for (let i = 0; i < 3; i++) {
		yield `<span>${i}</span>`;
	}
	yield `</div>`;
}

And the implementation of doBuilder(..):

function doBuilder(
	doRoutine,
	isMonoid = v => (v && typeof v.concat == "function"),
	deps = [],
	...args
) {
	return IOx.do(runner,deps);

	// ************************************
	
	async function *runner(context,...depsVals) {
		var concatIO = IO.of("");
		
		var it = doRoutine(context,...depsVals,...args);
		var res;
		while (true) {
			res = it.next(res);
			if (isPromise(res)) {
				res = await res;
			}
			else {
				let done = res.done;
				
				if (isMonad(res.value)) {
					if (IO.is(res.value)) {
						res = res.value.chain(concatIfMonoid);
					}
					else if (Nothing.is(res.value)) {
						return IO.of("");
					}
					else if (Either.is(res.value) || Maybe.is(res.value)) {
						res = res.value.fold(IO.of,concatIfMonoid);
					}
					else {
						res = res.value.fold(concatIfMonoid);
					}
				}
				else {
					res = concatIfMonoid(res.value);
				}

				res = yield res;
				if (done) {
					return concatIO.run(context);
				}
			}
		}
		
		// ************************************
		
		function concatIfMonoid(v) {
			if (isMonoid(v)) {
				concatIO = concatIO.concat(IO.of(v));
				return IO.of();
			}
			else {
				return IO.of(v);
			}
		}
	}
}

[getify]

Next revision/abstraction:

var id = IO.of(42);

strBuilderX(whatever,[ id ])
.map(v => console.log("html",v))
.run({});

function *whatever(context,id) {
	yield `<div id="${id}">`;
	for (let i = 0; i < 3; i++) {
		yield `<span>${i}</span>`;
	}
	yield `</div>`;
}

And the updated implementation:

function strBuilder(doRoutine,...args) {
	var runner = buildRunner(doRoutine,v => (v && typeof v == "string"),...args);
	return IO.do(runner);
}

function strBuilderX(doRoutine,deps = [],...args) {
	var runner = buildRunner(doRoutine,v => (v && typeof v == "string"),...args);
	return IOx.do(runner,deps);
}

function buildRunner(doRoutine,isMonoid = v => (v && typeof v.concat == "function"),...args) {
	return async function *runner(context,...depsVals){
		var concatIO = IO.of("");
		
		var it = doRoutine(context,...depsVals,...args);
		var res;
		while (true) {
			res = it.next(res);
			if (isPromise(res)) {
				res = await res;
			}
			else {
				let done = res.done;
				
				if (isMonad(res.value)) {
					if (IO.is(res.value)) {
						res = res.value.chain(concatIfMonoid);
					}
					else if (Nothing.is(res.value)) {
						return IO.of("");
					}
					else if (Either.is(res.value) || Maybe.is(res.value)) {
						res = res.value.fold(IO.of,concatIfMonoid);
					}
					else {
						res = res.value.fold(concatIfMonoid);
					}
				}
				else {
					res = concatIfMonoid(res.value);
				}

				res = yield res;
				if (done) {
					return concatIO.run(context);
				}
			}
		}
		
		// ************************************
		
		function concatIfMonoid(v) {
			if (isMonoid(v)) {
				concatIO = concatIO.concat(IO.of(v));
				return IO.of();
			}
			else {
				return IO.of(v);
			}
		}
	};
}

[getify]

else if (Nothing.is(res.value)) {
   return IO.of("");
}

This line needs to be generalized from using "" as the empty monoid value to having such a value parameterized to buildRunner(..).