Prompt Title: Composition over interface delegation

Composition and interface delegation are both techniques used to achieve code reuse and separation of concerns, but they're suitable for different scenarios. Here's when you might choose one over the other:

Composition:

When to Use:

1. Flexibility in Method Invocation: If you want the freedom to decide when, how, or even if to call a method on the composed object, use composition. It lets you wrap or modify methods, delay calls, etc.
2. Multiple Behaviors: When you want to use multiple components to implement multiple behaviors and there's no clean one-to-one delegation possible.
3. Partial Reuse: If you only need a subset of the functionalities of an existing class, composition allows for that selective reuse.

Pros:

1. High Flexibility: You have the freedom to decide which methods to expose, wrap, or even skip.
2. Clear Encapsulation: Using private members, you can hide the details of the composed objects.
3. Enhanced Control: You can control the lifecycle and the initialization of the composed objects.

Cons:

1. Verbosity: You might end up writing more boilerplate to forward calls.
2. Less Intuitive Relationships: It might not be as immediately clear that a class is "acting as" another class, unlike with delegation.

Interface Delegation:

When to Use:

1. Clean One-to-One Mapping: When one object should "act as" another without adding or changing behavior.
2. Avoid Boilerplate: When you want to reuse all or most methods of an interface and don't want to manually forward all the method calls.
3. Dynamic Behavior Swap: If you want to change the behavior of a class at runtime by switching which delegate it uses.

Pros:

1. Less Boilerplate: Kotlin's by keyword allows for clean and concise delegation without manual forwarding.
2. Clear "Act-As" Relationship: It’s evident that the class is meant to act-as or behave like the delegated interface.
3. Dynamic Behavior: The delegate can be switched out dynamically if needed, allowing for flexible behaviors at runtime.

Cons:

1. Less Control: Since delegation is automatic, you have less control over individual method calls.
2. Potential Exposure: All methods in the interface are automatically exposed. You can't selectively hide some methods (though you can wrap the delegate and expose a subset of methods that way).

In summary:

• Use composition when you need more control, flexibility, or a more complex combination of behaviors.

• Use interface delegation when there's a clean "act-as" relationship and you want a concise way to reuse functionality without a lot of boilerplate.

Remember, both are tools in your toolbox. The right choice often comes down to the specific needs of your design and what makes the most sense in the context of your application.