Idiomatic way to write an endless loop with break

[JanBeh]

I wonder what's the idiomatic way to have a program with an endless loop where it's possible to break out of the loop.

As an exercise to get accustomed to the Koka language, I tried to implement a simple number-guessing game. An easy way seems to do tail recursion:

import std/num/random
import std/os/readline

fun dice() : ndet int
  srandom-int32-range(1.int32, 7.int32).int

fun main()
  val num = dice()
  fun loop()
    println("Pick a number")
    match readline().parse-int
      Just(g) ->
        if g < num then println("Too small")
        elif g > num then println("Too big")
        else return ()
      _ -> ()
    loop()
  loop()
  println("Correct!")

I noticed that I have to write the function's identifier (loop) three times. Is there an easier way?

Is the correct way to define an effect and make an abstraction for the effect handler? That could look like this:

import std/num/random
import std/os/readline

fun dice() : ndet int
  srandom-int32-range(1.int32, 7.int32).int

effect break
  ctl break() : ()

fun loop( body : () -> <div,break|e> () ) : <div|e> ()
  with ctl break() {}
  while { True }
    body()

fun main()
  val num = dice()
  loop()
    println("Pick a number")
    match readline().parse-int
      Just(g) ->
        if g < num then println("Too small")
        elif g > num then println("Too big")
        else break()
      _ -> ()
  println("Correct!")

Is this idiomatic? Is while { True } idiomatic? Does something like the break effect exist in std? (I didn't find it, at least, but perhaps I was looking in the wrong place. I noticed it's a future reserved word though, according to the docs.)

Any comments on where my code is non-idiomatic or could be improved are appreciated. 🙏

---

I also tried to make the break effect generic:

effect break<r>
  ctl break( retval : r ) : a

fun bottom-workaround() : div a
  bottom-workaround()

fun loop( body : () -> <div,break<r>|e> () ) : <div|e> r
  with handler
    ctl break( retval ) { return retval }
  while { True }
    body()
  bottom-workaround()

And then:

 fun main()
   val num = dice()
   loop()
     println("Pick a number")
     match readline().parse-int
       Just(g) ->
         if g < num then println("Too small")
         elif g > num then println("Too big")
-        else break()
+        else break(())
       _ -> ()
   println("Correct!")

This works fine.

However, without bottom-workaround, I get the following error:

game.kk(16, 3): error: effects do not match
  context        :   with handler
                   ...
                       body()
  term           :   while { True }
                       body()
  inferred effect: <break<$a>,div|$e>
  expected effect: <break<()>|_e1>

Also, I haven't been able to add a type annotation here:

 fun loop( body : () -> <div,break<r>|e> () ) : <div|e> r
   with handler
-    ctl break( retval ) { return retval }
+    ctl break( retval : r ) { return retval }
   while { True }
     body()
   bottom-workaround()

As then I would get:

game.kk(15,25): error: Type r is not defined
  hint: bind the variable using forall<r> ?

But forall<k> isn't the solution:

-    ctl break( retval : r ) { return retval }
+    ctl break( retval : forall<r> r ) { return retval }

As it leads to:

game.kk(16, 3): error: effects do not match
  context        :   with handler
                   ...
                       body()
  term           :   while { True }
                       body()
  inferred effect: <div,break<$a>|$e>
  expected effect: <break<forall<b> b>|_e1>

So two additional questions in regard to the generic break<r> effect as defined above:

• How could I get rid of bottom-workaround?
• How could I annotate retval's type in the with handler statement?

[JanBeh]

I finally found a way to write this a bit more clean (also renaming break to terminate to avoid using a future reserved word) while being generic in regard to the loop's final return value:

import std/num/random
import std/os/readline

fun dice() : ndet int
  srandom-int32-range(1.int32, 7.int32).int

effect terminate<r>
  ctl terminate( retval : r ) : a

fun loop( body : () -> <div,terminate<r>|e> () ) : <div|e> r
  with ctl terminate( retval ) { return retval }
  fun inner()
    body()
    inner()
  inner()

fun main()
  val num = dice()
  loop()
    println("Pick a number")
    match readline().parse-int
      Just(g) ->
        if g < num then println("Too small")
        elif g > num then println("Too big")
        else terminate(())
      _ -> ()
  println("Correct!")

I still wonder if something like loop and terminate exists in the std library?