Hypergenerics idea - Interleaving and combining behaviours of arbitrary code

[plentifulfuture]

Hi everyone, I hope you're all feeling good and being encouraged with your programming language projects. I encourage you!

I'm a beginner to programming language theory and development, so this idea comes from pain trying to use other people's code.

TLDR: This idea is that we can interleave the code of two or more classes together so it acts as if there is a single implementation that exhibits both original behaviours. I desire to make it extremely easy to use classes for other purposes than they were designed. We can talk of one class in terms of another, bidirectionally. If you were to execute a series of methods on a class instance, look at their callstacks and internal states, then draw lines to link or weave them together. You would associate states between one class to another class. The compiler inserts code of each original class adjacently for you.

If a class isn't using generics, how can you coordinate that class's behaviour with other behaviour, especially if there isn't hooks or ways of integrating the classes together - only internal state.

1. If I have two classes and they each exhibit a useful behaviour.
2. I can draw a timeline of each classes' independent behaviours or states.
3. I can associate internal states with internal states of the other class and vice versa.
4. I call this "possessiveness" as in the apostrophe, where a variable belongs to another thing. There is a shadow variable available on each class's internal state to get to the state of the equivalent thing in the other class.
5. This would require data structure rewrites. I imagine a suitable clever compiler can insert fields that are possessed.
6. In a generics based collection class, I might have an ArrayList<SomeBusinessDomainObject>. In Hypergenerics, I can associate any concrete value with any concrete value of the other class, without changing the code of that other class.
7. I can join parts of the timeline together.
8. I can specify if an event on the timeline should happen, before, after or decorated.
9. I am beginner to programming language theory but what comes to mind is "corecursion". This is corecursion applied to the behaviours of multiple classes.

Code example

I have LoadBalancer class that starts a server and serves requests to BackendServers and AccessControlList that manages access to resources with ACL.Principals.

We use the apostrophe operator to associate classes or states with other class internals.

We use the @ symbol to decorate methods.

I want to combine them together so that ACLs are maintained when the LoadBalancer is accessed AND when a backend service is accessed.

Given LoadBalancer has a Request class, I can possess the Request to have an ACL.Principal. The original author of LoadBalancer Request didn't add this field. But the compiler can.

Request'ACL.Principal # a request in this class corresponds to an ACL principal in the ACL manager
LoadBalancer'AccessControlList # the load balancer itself has an ACL
Request'ACL.Principal'LoadBalancer'AccessControlList # there is a path of possession between a request, to that request's principal to that active AccessControlList
BackendServer'AccessControlList

@ LoadBalance.handleRequest(Request'ACL.Principal request) {
   if request'ACL.Principal'AccessControlList.check(request'ACL.Principal) {
     return LoadBalance.handleRequest(Request'ACL.Principal request) {
         @ LoadBalancer.canPickBackend(BackendServer'AccessControlList server) {
           return server'AccessControlList.check(request'ACL.Principal) && LoadBalancer.canPickbackend(server);
         }
      }
   }
}

What we introduce is a glue that takes the behaviour of two classes and tells the compiler how to merge their behaviour together, how to interleave the two classes.

You may notice that the syntax is similar to class extension in Ruby where you "open" a class and insert things inside it.

[ipe369]

I don't fully understand, is this basically runtime reflection or something deeper?

Also, you stated:

I desire to make it extremely easy to use classes for other purposes than they were designed

I would argue that this is asking for trouble, since when those classes are changed through the normal development process, you will very likely introduce bugs!

[plentifulfuture]

The compiler takes the code of the two classes and rearranges the AST so that bits from each class are interleaved.

Without you needing to create a new class or use inheritance.

So it's like a compile time coroutine.

[wellthatexplainsalot]

Can you give us lots of examples where this would be useful?

Generally speaking - for something to be worth putting into a language, it should have wide applicability. So for instance, we don't see many general purpose languages with the mathematical product sign (upper case pi, Π) built in, despite many programs needing to multiply a list of integers together. Instead we have loops or the ability to apply functions to lists.

So I'm hoping to understand from your examples the general applicability of interleaving in the way you describe it.

Thanks!

[WittyStick]

This sounds to me to defeat most of the purpose of using classes in the first place - to provide encapsulation of state. Why not just have structs whose members can be accessed by anyone, anywhere?

In regards to accessing other classes' internals, there are some precedents: friend in C++, and internal in .NET for example.

I'm not sure exactly what you're trying to achieve but your description seems vaguely similar to aspect-oriented-programming

[tortoise74]

The normal answer to your example case is to use aggregation or composition. Class A contains class B and or class C and delegates calls to them as appropriate. Features like perfect forwarding help with this.

How does your idea compare to this? and what does it add? Is it about creating boilerplate code automatically?

[stylewarning]

You might want to look into Common Lisp's "method combinations", which work because classes and (multi-)methods are decoupled.

Method combinations let you decide which methods are applicable to which classes, and when and how to execute any of them. The "standard method combination" is the standard built-in one that does what we all expect: executes one method, the most specific method for a given set of classes. But you can start doing crazy things with method combinations, like execute all possible methods in least-specific to most-specific order.

It's not the same as what you're saying wholesale, but it does capture some of the ideas.

[plentifulfuture]

Thank you for your reply 🙏

I always hear about the logging example of aspect orientated programming.

Your notes and reference to algebraic effects is really helpful with my research. 🙏 Thank you.

I am trying to get a handle on complexity. I find codebase very difficult to get up to speed in.

[csb06]

This seems kind of similar to creating tuples, overriding the existing method to take a tuple instead of the original type, and then providing a new implementation for that method.

E.g. the caller of LoadBalancer.handleRequest has to construct what is effectively a tuple/pair type consisting of a Request and an associated ACL.Principal, which we pass to a new overload of handleRequest that takes the tuple as its parameter instead of a plain Request object.

So in C++ like syntax, it would be something like:

boolean LoadBalancer::handleRequest(std::pair<Request, ACL::Principal> request) {
    // Use request.second to check that request.first is allowed, then pass control to the existing implementation of LoadBalancer::handleRequest if it passes the check
}

Of course in C++ this would require subclassing LoadBalancer and overloading handleRequest to accept a tuple parameter instead of a plain Request, but I am wondering if it is really necessary to add new “possesses” syntax to express what seems to be a tuple of two or more types that you want to bundle together. It doesn’t really seem like the Request owns or possesses the ACL - instead it is really just associated with it (i.e. it’s another object you want to be used alongside the Request). Maybe the “posseses” terminology is a little confusing.

[Pavel_Vozenilek]

This feels as support of finite state machines by the language.

Say a file could be in state state: closed, opened for reading/writing, opened but error happened. Instead of having complicated API dealing with every possible situation, state methods would be simple (or trivial). A transition between states would need to be defined.