polymorph | Polymorph is a real-time network packet manipulation framework with support for almost all existing | Networking library

I wish someone can prove me wrong, but this is one of the few corner cases where we meet a limitation of current GHC and we can not get away from using Proxy, Tagged or similar "relics" of the past.

Let's consider a simpler example:

No, not until closure HRTB inference is fixed. Current workarounds include using function pointers instead or implementing a helper trait on custom structs -- the helper trait is needed regardless of approach until higher-kinded types are introduced in Rust.

Playground

To avoid returning a Box, you would need the type parameter I to be generic over the lifetime 'a, so that you can use it with any lifetime (in a for<'a> bound, for example). Unfortunately, as discussed in a similar question, Rust does not yet support higher-kinded types (type parameters that are themselves generic over other type parameters), so we must use a helper trait:

Assuming that you're talking about the language feature (e.g. interface keyword in Java), as opposed to the general computing term, the purpose of interfaces is polymorphism.

A tool such as interfaces can be abused for other purposes, for example:

• As a way of communicating commonality - this can backfire, because if polymorphism isn't the goal of the design, then the classes which declare implementing the interface are making an unnecessary commitment to implement it. That may cease to be relevant when the commonality is eventually broken, which can happen because the classes aren't used polymorphically.

• As a way of documenting the contract and allowing the class implementation to change - In Java, this is achieved with public/protected methods with Javadoc are the way to document the contract. Some languages don't even have that, and they still document contracts. Of course, this only works if the contract comes in form of function calls (as opposed to e.g. RESTful HTTP APIs), and it only works if you have a rule about what you document, e.g. package boundary; you wouldn't want to create an interface for every class, even if you document the contract for every class.

• To physically hide stuff from the consumer of your interface - this is also about documenting the contract, but if your class has data, or protected methods, and you want to prevent anything outside your package from inheriting, you can expose only an interface. But you can also use final.

Interfaces aren't designed to achieve multiple inheritance; they rather facilitate multiple inheritance only to the extent that is useful for polymorphism; it doesn't really allow you to inherit any fields, and until recently in Java with default methods (so, not by design), not even code.

You would see, in the wild, packages where only one class implements the interface. That doesn't render the interface useless; more implementations may come in the future, and in fact, the package might want to allow callers to offer their own implementation.

The following are just some ideas that i came up with while thinking about it - there might be better solutions that i'm not aware of.

Using Tag-Dispatch you can define an order in which the functions should be considered by the compiler, e.g. in this case it's

Variance and injectivity annotations give back some information about the relationship between an abstract type constructor type 'a t and its argument. For instance, a type constructor could either

• produce or contain an 'a:

The issue is that the 'a type variable in the (l': 'a t) annotation lives in the whole toplevel definition and thus outlives the polymorphic annotation.

In order to illustrate this scope issue for type variables, consider

For your first point, the relaxed value restriction is triggered as soon as any computation happens in any sub-expression. Thus neither

I recommend you use StandaloneKindSignatures:

The interaction could be managed by the base class itself. Something like this: