Retroactive interface conformance

[KnightBreaker]

It would be great to look at other languages strengths and potentially mimic those in verse.

Right now we can conform a class of our control to an interface and that‘s it. But other languages can do it retroactively. This means that you can extend other classes which you might not own with your own interfaces.

Unlike current extensions which only provide a single non-referencible method, an extension like this would provide everything interfaces already offer, as long as the conformance conditions can be met.

Bikeshedding syntax:

extend my_snake_verse_type with my_snake_verse_interface <# where ... #>:
  # code
  # goes
  # here

The extend ... { ... } introduces a full new scope where the developer can provide implementation for multiple methods and computed properties. It doesn't have to be limited to interface (trait?) conformance only.

The hypothetical with my_interface is the actual retroactive conformance, where on the right hand side there could be an optional where clause for conditional conformance.

To give a quick hypothetical example:

my_foo_interface := interface {
  Foo(): void
}

CallFoo(I: my_foo_interface): void = {
  I.Foo()
}

my_generic_class(t: type) := class {}

extend my_generic_class with my_foo_interface where t: subtype(my_foo_interface) {
  Foo(): void = { ... }
}

foo_class := class(my_foo_interface) { ... }
non_foo_class := class { ... }

A := my_generic_class(foo_class) {}
B := my_generic_class(non_foo_class) {}

CallFoo(A) # okay

# error `my_generic_class(non_foo_class)` does not conform to `my_foo_interface`
# as `non_foo_class` does not conform to `my_foo_interface`
CallFoo(B) 

This feature is inspired by Swift.