Spec: dynamic dispatch

[eudoxia0]

Closures, or some light OOP.

[miniBill]

Does it make sense to have a FunctionN type class (with N from 0 to, say, 8) with a call(arg0,..., argN) method, and have the closure be compiled to a struct of the closed over variables? So a lambda would be linear iff it uses linear variables.

Main issue I can see is that iirc this requires actual type inference

[eudoxia0]

So, my (very brief and compressed) thoughts on this:

Typeclasses do static dispatch. In a sense that's "all you need". But unless you want every type and function to be generic (with the associated compilation cost), you usually want a way to do dynamic dispatch. There's two ways to do this, broadly:

1. Closures
2. Lightweight OOP

I have some thoughts (which I hope I wrote down somewhere) on how to do this while preserving the soundness of the linear type system. It is possible. I just haven't worked on implementing this yet, because I think having a usable/practical stdlib and basic tooling is more valuable than this feature at present.

[miniBill]

Functional approaches will always get my vote, so Closures over OOP 😆

But yeah, this doesn't seem to be a priority right now 🙂