Composition over inheritance in last lessons

Remaining lessons, you both love them or hate them. Folks have been utilizing them extra not too long ago of their open-source packages, however what does that imply for you? How do you deal with this in software code?

Builders have been discussing composition over inheritance for years, and last lessons are an ideal use case. A current instance I used to be speaking to somebody about was ‘moneyphp/cash’, which carried out last lessons. Let’s dive in.

Let’s take the instance of ‘moneyphp/cash’ and take a look at how we’d combine with it. Earlier than last lessons, we’d lengthen the Cash class and use it as I have to. Nevertheless, that isn’t attainable anymore, so we wish to discover a option to work with it. We are going to create a category known as MoneyImplementation which would be the class we wish to use.

 1class MoneyImplementation
 2{
 3    non-public Cash $cash;
 4 
 5    public operate __construct(
 6        int|string $quantity,
 7        Foreign money $forex,
 8    ) {
 9        $this->cash = new Cash(
10            quantity: $quantity,
11            forex: $forex,
12        );
13    }
14}

So within the code above, we have now used composition to construct a category that may proxy its development to the cash class – setting a property on the category to the constructed occasion. The following downside is how can we name class strategies on the cash class with out extending the API we wish to name. With out including this, we must add an accessor to get the cash occasion from our class, after which use the accessor like the next.

1$cash = new MoneyImplementation(
2    quantity: 10_000,
3    forex: new Foreign money(
4        code: 'USD',
5    ),
6);
7 
8$cash->cash()->getAmount();

This is not splendid, however with none further work, that is acceptable. However we will take it one step additional utilizing just a little PHP magic. Let’s add this magic technique to our MoneyImplementation class.

 1class MoneyImplementation
 2{
 3    non-public Cash $cash;
 4 
 5    public operate __construct(
 6        int|string $quantity,
 7        Foreign money $forex,
 8    ) {
 9        $this->cash = new Cash(
10            quantity: $quantity,
11            forex: $forex,
12        );
13    }
14 
15    public operate __call(string $title, array $arguments)
16    {
17        if (! method_exists($this->cash, $title)) {
18            throw new RuntimeException(
19                message: "Technique [$name] doesn't exist.",
20            );
21        }
22 
23        return $this->cash->{$title}(...$arguments);
24    }
25}

We add a technique __call to our class so we will proxy the decision straight to the cash occasion we have now already constructed. Earlier than that, nevertheless, we will add a security examine to make sure the strategy exists. Utilizing this, we will now simplify the API.

1$cash = new MoneyImplementation(
2    quantity: 10_000,
3    forex: new Foreign money(
4        code: 'USD',
5    ),
6);
7 
8$cash->getAmount();

This will not be one of the best instance as an example the purpose as we’ve not added something to our class. Nevertheless, it illustrates how we will use composition over inheritance to get round last package deal lessons.

Have you ever discovered a workaround for this? How would you deal with this state of affairs? Tell us on Twitter.