add SyncGenerator

Author: Simn

src/hxcoro/generators/SyncGenerator.hx

@@ -0,0 +1,97 @@
+package hxcoro.generators;
+
+import haxe.Exception;
+import haxe.coro.Coroutine;
+import haxe.coro.IContinuation;
+import haxe.coro.context.Context;
+import haxe.coro.dispatchers.Dispatcher;
+import haxe.coro.dispatchers.IDispatchObject;
+import haxe.exceptions.CoroutineException;
+import hxcoro.Coro.*;
+
+@:coroutine.restrictedSuspension
+typedef Yield<T> = Coroutine<T -> Void>;
+
+private class GeneratorImpl<T> extends Dispatcher implements IContinuation<Any> {
+	public var context(get, null):Context;
+
+	final f:Coroutine<Yield<T> -> Void>;
+	var nextValue:Null<T>;
+	var nextStep:Null<IContinuation<T>>;
+	var resumed:Bool;
+
+	public function new(f:Coroutine<Yield<T> -> Void>) {
+		this.context = Context.create(this);
+		this.f = f;
+		resumed = true;
+	}
+
+	function get_context() {
+		return context;
+	}
+
+	function get_scheduler() {
+		return throw new CoroutineException('Cannot access scheduler on Generator contexts');
+	}
+
+	public function hasNext() {
+		if (nextStep == null) {
+			f(this, yield);
+		} else if (!resumed) {
+			nextStep.resume(null, null);
+		}
+		return !resumed;
+	}
+
+	public function next() {
+		return nextValue;
+	}
+
+	public function resume(result:Null<Any>, error:Null<Exception>) {
+		resumed = true;
+		if (error != null) {
+			throw error;
+		}
+	}
+
+	public function dispatch(obj:IDispatchObject) {
+		obj.onDispatch();
+	}
+
+	@:coroutine function yield(value:T) {
+		resumed = false;
+		nextValue = value;
+		suspend(cont -> {
+			nextStep = cont;
+		});
+	}
+}
+
+/**
+	A synchronous generator that can be used as an `Iterator`.
+**/
+abstract SyncGenerator<T>(GeneratorImpl<T>) {
+	/**
+		@see `Iterator.hasNext`
+	**/
+	public inline function hasNext() {
+		return this.hasNext();
+	}
+
+	/**
+		@see `Iterator.next`
+	**/
+	public inline function next() {
+		return this.next();
+	}
+
+	/**
+		Creates a new generator that produces values by calling and resuming `f`.
+
+		The coroutine `f` is executed in a restricted suspension scope, which means
+		that it cannot call arbitrary coroutines that might suspend.
+	**/
+	static public function create<T>(f:Coroutine<Yield<T> -> Void>) {
+		return new GeneratorImpl(f);
+	}
+}

src/hxcoro/task/ICoroNode.hx

@@ -1,9 +1,9 @@
 package hxcoro.task;
 
-import haxe.exceptions.CancellationException;
 import haxe.coro.context.Context;
-import haxe.coro.context.Key;
 import haxe.coro.context.IElement;
+import haxe.coro.context.Key;
+import haxe.exceptions.CancellationException;
 import hxcoro.task.ICoroTask;
 
 interface ICoroNodeWith {
@@ -14,6 +14,7 @@ interface ICoroNodeWith {
 	function without(...keys:Key<Any>):ICoroNodeWith;
 }
 
+@:coroutine.scope
 interface ICoroNode extends ICoroNodeWith {
 	var id(get, never):Int;
 	@:coroutine function awaitChildren():Void;

tests/src/TestGenerator.hx

@@ -1,54 +1,12 @@
 import hxcoro.dispatchers.TrampolineDispatcher;
 import hxcoro.task.CoroTask;
 import haxe.coro.context.Context;
+import hxcoro.generators.SyncGenerator;
 import haxe.Exception;
 
-private typedef Yield<T> = Coroutine<T->Void>;
-
-private function sequence<T>(f:Coroutine<Yield<T>->Void>):Iterator<T> {
-	var hasValue = false;
-	var nextValue:T = null;
-	var exception:Null<Exception> = null;
-
-	var nextStep = null;
-	final scope = new CoroTask(Context.create(new TrampolineDispatcher()), CoroTask.CoroScopeStrategy);
-
-	@:coroutine function yield(value:T) {
-		nextValue = value;
-		hasValue = true;
-		suspend(cont -> {
-			nextStep = () -> {
-				hasValue = false;
-				cont.resume(null, null);
-				if (!scope.isActive()) {
-					exception = scope.getError();
-				}
-			}
-		});
-	}
-
-	nextStep = () -> {
-		f(scope, yield);
-		scope.start();
-	}
-
-	function hasNext() {
-		nextStep();
-		if (exception != null) {
-			throw exception;
-		}
-		return hasValue;
-	}
-	function next() {
-		return nextValue;
-	}
-
-	return {hasNext: hasNext, next: next};
-}
-
 class TestGenerator extends utest.Test {
 	function testSimple() {
-		var iter = sequence(yield -> {
+		var iter = SyncGenerator.create(yield -> {
 			yield(1);
 			yield(2);
 			yield(3);
@@ -64,7 +22,7 @@ class TestGenerator extends utest.Test {
 		}
 
 		function iterTree<T>(tree:Tree<T>):Iterator<T> {
-			return sequence(yield -> iterTreeRec(yield, tree));
+			return SyncGenerator.create(yield -> iterTreeRec(yield, tree));
 		}
 
 		var tree:Tree<Int> = {
@@ -86,7 +44,7 @@ class TestGenerator extends utest.Test {
 	function testException() {
 		final result = [];
 		Assert.raises(() -> {
-			for (i in sequence(yield -> {
+			for (i in SyncGenerator.create(yield -> {
 				yield(1);
 				yield(2);
 				throw "oh no";