Program hanging after main? (and some other questions)

[osa1]

I have this "guess the number" game implementation in Effekt:

import bytearray
import io/console
import io/error
import io/filesystem

interface Random {
    def randomByte(): Int
}

def main() = {
    with on[IOError].panic();
    val c = js::newConsole()
    try {
        guessTheNumberIO();
    } with Random {
        def randomByte() = resume(randomByteIO())
    } with Console {
        def readLine() = resume(js::readLine(c))
        def writeLine(content) = resume(js::writeLine(c, content))
    }
    println("out of the main function");
}

def randomByteIO(): Int / Exception[IOError] = {
    var devRandom = open("/dev/random", ReadOnly());
    var byteArray = bytearray::allocate(1);
    read(devRandom, byteArray, 0, 1, 0);
    close(devRandom);
    byteArray.unsafeGet(0).toInt
}

def guessTheNumberIO(): Unit / {Console, Random} = {
    var number = 10; // do randomByte();
    loop { {l} =>
        do writeLine("Your guess?");
        var guess = do readLine();

        var guessInt = try {
            Some(guess.toInt())
        } with Exception[WrongFormat] {
            def raise(exception, msg) = {
                do writeLine("That's not an int!");
                None()
            }
        };

        guessInt match {
            case None() => l.continue
            case Some(i) => {
                if (i < number) {
                    do writeLine("Too small");
                } else if (i > number) {
                    do writeLine("Too large");
                } else {
                    do writeLine("You guessed it!");
                    l.break();
                }
            }
        }
    }
    do writeLine("out of the loop");
    ()
}

If you run this and enter "10", it prints "out of the loop" so the break works as expected, and it also prints "out of the main function" which is the last statement in main, but the process never terminates. Is this expected?

I also have a question on how to simplify this code. In this block:

var guessInt = try {
    Some(guess.toInt())
} with Exception[WrongFormat] {
    def raise(exception, msg) = {
        do writeLine("That's not an int!");
        None()
    }
};

Can I "continue" in case of an exception, instead of returning a value? I tried this:

var guessInt = try {
    guess.toInt()
} with Exception[WrongFormat] {
    def raise(exception, msg) = {
        do writeLine("That's not an int!");
        l.continue()
    }
}

But it fails with

[error] guess_the_number.effekt:43:17: Cannot typecheck call.
There are multiple overloads, which all fail to check:

Possible overload: effekt::loop of type {() => Unit} => Unit
  Wrong number of block arguments, given 1, but function expects 0.

Possible overload: effekt::loop of type {{Control} => Unit} => Unit
  Expected Int but got Unit.

                l.continue()
                ^^^^^^^^^^^^

My understanding of the error is that the raise handler's return value needs to be an Int, which l.continue() isn't.

Is there a way to make this work?

I also tried return l.continue() as if I understand this correctly, the process passed to loop needs to return the control flow value to loop, but that also didn't work.

Also a question: As far as I can see, there isn't a resumable exception effect in the standard library. Is there a limitation in the langauge that makes this impossible? Or is it just that you didn't have a use for it?

[jiribenes]

Hi, thanks for the questions!

Here are my attempts at answering them:

Console hanging

As far as I can tell, the program doesn't stop because the Console c is not closed properly with js::close(c), so it's not cleaned up as a resource, therefore the JavaScript runtime is leaving the process waiting indefinitely for more input/output.

We have a console handler defined in io/console in stdlib which interprets the effect correctly and ensures cleanup:

effekt/libraries/common/io/console.effekt

Lines 10 to 21 in b034213

	/// Handler for the console effect, using the Console available in js
	def console[R] { program: () => R / Console }: R = {
	val c = js::newConsole()
	try {
	val r = program()
	js::close(c)
	return r
	} with Console {
	def readLine() = resume(js::readLine(c))
	def writeLine(message) = resume(js::writeLine(c, message))
	}
	}

After using the console handler, the following main seems to work on my machine:

def main() = {
    with on[IOError].panic();
    with console;

    try {
        guessTheNumberIO();
    } with Random {
        def randomByte() = resume(randomByteIO())
    }
    println("out of the main function");
}

(where with foo; ... is syntax sugar for foo { ... })

continue in guessInt

This is a typing problem.

One quick way to resolve this issue is to make a Control effect and loop like there is in the stdlib which returns Nothing (I called it Ctrl here):

interface Ctrl {
    def break(): Nothing
    def continue(): Nothing 
}

def loop { f: {Ctrl} => Unit }: Unit = try {
    def go(): Unit = { f {label}; go() }
    go()
} with label: Ctrl {
    def break() = ()
    def continue() = loop { f }
}

def guessTheNumberIO(): Unit / {Console, Random} = {
    var number = 10; // do randomByte();
    loop { {l} =>
        do writeLine("Your guess?");
        val guess = do readLine();

        val guessInt = try {
            guess.toInt()
        } with Exception[WrongFormat] {
            def raise(exception, msg) = {
                do writeLine("That's not an int!");
                l.continue()
            }
        }

        if (guessInt < number) {
            do writeLine("Too small");
        } else if (guessInt > number) {
            do writeLine("Too large");
        } else {
            do writeLine("You guessed it!");
            l.break();
        }
    }

    do writeLine("out of the loop")
}

The reason your version doesn't work is because the types don't match -- here's an example of how a try-with is type checked:

effect foo(x: T1): T2

try {
  myFunction() // has effects {foo, bar}
  // the final type here has to be some type `T3`
} with foo { (x: T1) =>
  // all `resume`s here have type `T2 => T3`
  // whatever's here has to have type `T3`
} // the whole `try-with` expression has type `T3` and effect `bar`

In your version, the block in try { ... } has type Option[Int], but the block in def raise = { ... } has type Unit which are incompatible.
In my version above it's Int and Nothing respectively which works because of subtyping: Nothing is the bottom type in Effekt.

A different way: while instead of loop

You can also use Effekt's version of while let with some "StopIteration" effect ala Python that I called stop (something similar is in the stream library in stdlib):

effect stop(): Nothing
def boundary { program: () => Any / stop }: Unit / Console = {
    try { program(); () } with stop { () }
    do writeLine("out of the loop")
}

def guessTheNumberIO(): Unit / {Console, Random} = {
    def getInput(): Option[Int] = {
        do writeLine("Your guess?");
        val guess = do readLine(); 

        with on[WrongFormat].option; // handler for WrongFormat defined in `option` in stdlib
        guess.toInt()
    }

    val number = 10; // do randomByte();

    with boundary; // handler for `stop` defined above
    while (getInput() is Some(guessInt)) {
      if (guessInt < number) {
            do writeLine("Too small");
        } else if (guessInt > number) {
            do writeLine("Too large");
        } else {
            do writeLine("You guessed it!");
            do stop() // stops the iteration
        }
    }
}

I can't really say whether this is any more or less idiomatic, but I just wanted to point out that this is also a way to write the program.

Resumable exceptions in stdlib

As far as I can see, there isn't a resumable exception effect in the standard library. Is there a limitation in the langauge that makes this impossible? Or is it just that you didn't have a use for it?

There's definitely no limitation in the language, you can definitely define resumable exceptions with a declaration like effect throw(msg: String): Unit.

@b-studios can probably explain this, but personally I think that the reason it's not in the stdlib is that we tend to define resumable exceptions for a specific problem at hand with a domain-specific name and behaviour for that problem.
However, the standard library is very experimental and changing quite often as we keep on writing more Effekt programs, so who knows :)

[osa1]

Thanks for the detailed answer, this is really helpful!