Mutual recursive objects - when to allow them?

[marzipankaiser]

Assume we defined:

interface Ping { def ping(): Unit }
interface Pong { def pong(): Unit }

Then, the following top-level definition is accepted by Effekt (albeit not working for LLVM):

def pinger = new Ping { def ping() = ponger.pong() }
def ponger = new Pong { def pong() = pinger.ping() }

(let's ignore non-termination here, we could add a counter).

Locally in a function, this does not compile (ponger is not defined):

def foo() = {
  def pinger = new Ping { def ping() = ponger.pong() }
  def ponger = new Pong { def pong() = pinger.ping() }
  ()
}

Also, the following (which uses boxing implicitly) doesn't work (locally or globally):

def mkPing {ponger: Pong} = new Ping { def ping() = ponger.pong() }
def mkPong {pinger: Ping} = new Pong { def pong() = pinger.ping() }

def pingr = unbox mkPing { pongr }
def pongr = unbox mkPong { pingr }

IIUC, this means that mutually recursive interface definitions are only possible on the toplevel, and not in LLVM.
Is this the behavior we want? Which of those should work? (Are there interesting other variants?)

[marzipankaiser]

Leveraging boxing, we could think it's possible to:

def pingr2 = unbox mkPing { unbox mkPong { pingr2 } }

But this fails with

[error] pingpong.effekt:19:44: Could not resolve term pingr2
def pingr2 = unbox mkPing { unbox mkPong { pingr2 } }
                                           ^^^^^^

[b-studios]

This is an interesting question, which is also related to #274.

In general, we need to rethink / redesign the "object-system" anyways. Other aspects are:

• toplevel objects (can those be mutually recursive?)
• classes
• implementing multiple interfaces
• objects as members
• private methods
• "extension" methods
• fields

Maybe the different aspects can be collected somewhere in a "super-ticket"?

[marzipankaiser]

Note: Workaround(-ish) I use for local mutually "recursive" objects via unrolling:

def withPing[R]{ b: {Ping} => R }: R = {
  def pi = new Ping {
    def ping() = withPong { {b} => b.pong() }
  }
  b{pi}
}
def withPong[R]{ b: {Pong} => R }: R = {
  def po = new Pong {
    def pong() = withPing { {b} => b.ping() }
  }
  b{po}
}