Handling multiple effects without with?

[osa1]

I can't figure out how to handle multiple effects with handle.

If I just list the operations in handle it fails with "operator ... is not part of the handled effect".

There should be some way of nesting handles, but I can't figure out the syntax.

Here's what I have:

fun test1(test: test-case): <div,exn>()
  var inputs := test.inputs
  var outputs := Nil
  var num := test.num

  handle game
    fun random-int32()
      num

    ctl readline1()
      match inputs
        Cons(line, nextLines) ->
          inputs := nextLines
          resume(line)
        Nil ->
          throw-exn(Exception(message = "blah", info = ExnAssert))

    ctl println1(s: string)
      outputs := Cons(s, outputs)
      resume(())

readline1 and println1 belong to console1, random-int32 is the random effect from std.

I tried nesting it like

  handle
    handle game
      fun random-int32()
        num

    ctl readline1()
      match inputs
        Cons(line, nextLines) ->
          inputs := nextLines
          resume(line)
        Nil ->
          throw-exn(Exception(message = "blah", info = ExnAssert))

    ctl println1(s: string)
      outputs := Cons(s, outputs)
      resume(())

But that's a syntax error.

The reason why I don't want with is becaues I will be doing more stuff after game, and I don't want the effects to be handled after game.

Full code

import std/core/exn
import std/core/int
import std/num/int32
import std/num/random
import std/os/env
import std/os/readline

pub fun main()
  match get-args()
    Cons("--test", Nil) ->
      ()

    Cons(_, _) ->
      println("Unexpected command line argument(s)")

    Nil ->
      with console1-terminal
      game()

fun game(): <console1, random, div>()
  val num = match try({ random-int32().abs() })
    Error(_) -> min-int32
    Ok(num) -> num
  println1("Your guess?")
  loop(num)

fun loop(num: int32): <console1, div>()
  val line = readline1()

  val i = match parse-int(line)
    Nothing ->
      println1("That's not an int!")
      return loop(num)
    Just(i) ->
      i32(i)
      
  match i.cmp(num)
    Eq ->
      println1("Found it!")

    Lt ->
      println1("Too low")
      loop(num)

    Gt ->
      println1("Too high")
      loop(num)

effect console1
  ctl println1(s: string): ()
  ctl readline1(): string

val console1-terminal = handler
  ctl readline1()
    match try(readline)
      Error(_) -> ()
      Ok(line) -> resume(line)

  ctl println1(s: string)
    println(s)
    resume(())

struct test-case 
  num: int32
  inputs: list<string>
  outputs: list<string>

fun test(test-cases: list<test-case>): <div,exn>()
  test-cases.foreach(test1)

fun test1(test: test-case): <div,exn>()
  var inputs := test.inputs
  var outputs := Nil
  var num := test.num

  handle
    handle game
      fun random-int32()
        num

    ctl readline1()
      match inputs
        Cons(line, nextLines) ->
          inputs := nextLines
          resume(line)
        Nil ->
          throw-exn(Exception(message = "blah", info = ExnAssert))

    ctl println1(s: string)
      outputs := Cons(s, outputs)
      resume(())

[chtenb]

Using nested handles, I think you can do this:

  handle ({
    handle (game)
      fun random-int32()
        num
  })
    ctl readline1()
      match inputs
        Cons(line, nextLines) ->
          inputs := nextLines
          resume(line)
        Nil ->
          throw-exn(Exception(message = "blah", info = ExnAssert))

    ctl println1(s: string)
      outputs := Cons(s, outputs)
      resume(())

The handle keyword expects a parameterless function and runs it, so you need the additional braces to delay execution for the next handle.

[osa1]

Thanks. This works, but the syntax is terrible. Is there another way to do this? Can I limit the scope of with statements maybe?

[chtenb]

Good question. Obviously one solution could be to keep using with but isolate the code into a separate function.
Another approach could be to use handler for the first nesting level, and with for the second:

  (handler{ fun random-int32() num })
    with handler
      ctl readline1()
        match inputs
          Cons(line, nextLines) ->
            inputs := nextLines
            resume(line)
          Nil ->
            throw-exn(Exception(message = "blah", info = ExnAssert))

      ctl println1(s: string)
        outputs := Cons(s, outputs)
        resume(())
      
    game()

Or you could first setup the handlers and then call them

  val r = handler
    fun random-int32() 
      num
  val c = handler
    ctl readline1()
      match inputs
        Cons(line, nextLines) ->
          inputs := nextLines
          resume(line)
        Nil ->
          throw-exn(Exception(message = "blah", info = ExnAssert))

    ctl println1(s: string)
      outputs := Cons(s, outputs)
      resume(())
      
  r({c(game)})

Maybe there are other aproaches I missed

[TimWhiting]

If you are just avoiding with due to the scoping issue, I would just create a local variable for the result, and use an indented block
This is how I usually limit the scope of with

  val result = // A local value can be defined in an indented block (since every block is also an expression)
    with handler
      fun random-int32()
        num
    // game will be run under this handler, and the handler will not be in scope after.
    game()
  with handler
    ctl readline1()
      match inputs
        Cons(line, nextLines) ->
          inputs := nextLines
          resume(line)
        Nil ->
          throw-exn(Exception(message = "blah", info = ExnAssert))

    ctl println1(s: string)
      outputs := Cons(s, outputs)
      resume(())
  ...

[osa1]

Good tip, thanks. I think this reads better than nested handles. Here's my code with this style:

fun test1(test: test-case): <div,exn>()
  var inputs := test.inputs
  var outputs-found := Nil
  var num := test.num
  var random-used := False

  val _ =
    with handler 
      fun random-range(low: int32, high: int32)
        if random-used then
          throw("random number used multiple times", ExnAssert)
        if num < num || num >= high then
          throw(
            "Test random number " ++ num.show ++ " is not in range (" ++ low.show ++ ", " ++ high.show ++ ")",
            ExnAssert
          )
        random-used := True
        num

    with handler 
      ctl readline1()
        match inputs
          Cons(line, nextLines) ->
            inputs := nextLines
            resume(line)
          Nil ->
            throw("readline after all inputs are consumed", ExnAssert)

      ctl println1(s: string)
        outputs-found := Cons(s, outputs-found)
        resume(())

    game()

  if outputs-found.reverse() == test.outputs then
    throw("outputs don't match", ExnAssert)

  if !inputs.is-empty() then
    throw("test didn't consume all inputs", ExnAssert)