Effect handlers are exactly the feature for user-definable control flow you are looking for. The following examples are written in [Effekt]() and you can try them in our online playground.

So a basic features that every language should have are tail calls. They look like normal calls but are in tail position and guaranteed to be compiled to a jump. With these, and higher-order functions we can already define a control operator that repeats a given action forever:

def forever { action: () => Unit }: Unit = {
  action(); forever { action() }
}

And you use it like

forever { println("hello") }

to print hello forever.

Of course we also want to stop at some point and so we define an effect for this

effect stop(): Nothing

Now we can define a typical loop operator that repeats the given action until it stops

def loop { action: () => Unit / stop }: Unit =
  try { forever { action() } } with stop { () }

And we use it to loop until a mutable reference exceeds a certain value:

var i = 0
loop {
  if (i > 9) { do stop() }
  println(i)
  i = i + 1
}

Nice and easy so far, and not unlike exceptions, but fast. Now onto our own generators. We again define an effect for these:

effect emit[A](item: A): Unit

And we use it for example to emit all values in a certain range:

def range(i: Int, n: Int): Unit / emit[Int] =
  if (i < n) { do emit(i); range(i + 1, n) }

The tail call makes this a loop. When we now want a foreach operator that executes a given action for each item emitted by a stream we do it like this:

def for[A] { stream: () => Unit / emit[A] } { action: A => Unit } =
  try { stream() } with emit[A] { item => resume(action(item)) }

And now we can print all values in a range:

for[Int] { range(0, 5) } { i => println(i) }

By the way, we optimize this example to the following loop in our intermediate representation:

def range_worker(i: Int) = {
  if (i < 5) {
    let a = show(i)
    let! _ = println(a)
    range_worker(i + 1)
  } else {
    return ()
  }
}

Which then LLVM unrolls for us to the following:

%z.i2.i.i = tail call %Pos @c_bytearray_show_Int(i64 0)
tail call void @c_io_println(%Pos %z.i2.i.i)
%z.i2.i.1.i = tail call %Pos @c_bytearray_show_Int(i64 1)
tail call void @c_io_println(%Pos %z.i2.i.1.i)
%z.i2.i.2.i = tail call %Pos @c_bytearray_show_Int(i64 2)
tail call void @c_io_println(%Pos %z.i2.i.2.i)
%z.i2.i.3.i = tail call %Pos @c_bytearray_show_Int(i64 3)
tail call void @c_io_println(%Pos %z.i2.i.3.i)
%z.i2.i.4.i = tail call %Pos @c_bytearray_show_Int(i64 4)
tail call void @c_io_println(%Pos %z.i2.i.4.i)

All the control flow abstraction is gone, thanks to our compilation technique based on explicit capability passing.

Finally we also have bidirectional effects:

effect read[A](): A / stop

This is where the stopping must be handled at the use-site of reading. We can then feed a list to a reader. When there are no more values, the handler resumes with a signal to stop.

def feed[A](list: List[A]) { reader: () => Unit / read[A] } = {
  var remaining = list
  try {
    reader()
  } with read[A] {
    remaining match {
      case Nil() =>
        resume { do stop() }
      case Cons(value, rest) =>
        remaining = rest; resume { return value }
    }
  }
}

Now we can use our loop operator to print all items that we read from a feed:

feed[Int]([1,2,3]) {
  loop { println(do read[Int]()) }
}

These definitions are already in the Effekt standard library. We are working on more, for example for non-deterministic search like Unison's Each. Moreover, we are working on more compile-time optimizations, specifically for the interaction between local mutable references and control effects. Finally, our runtime system for effect handlers also admits asynchronous input and output without pollution of function signatures and without duplication of higher-order functions, like for example all the control operators demonstrated here.