Container vs Composite vs Chain

greeter.php

<?php
interface Greeter
{
    public function greet($name);
}

class ChainGreeter implements Greeter
{
    private $greeters = [];
    
    public function addGreeter(Greeter $greeter)
    {
        $this->greeters[] = $greeter;
    }
    
    public function greet($name)
    {
        foreach ($this->greeters as $greeter) {
            $greeter->greet($name);
        }
    }
}

class StringGreeter() implements Greeter
{
    private $sentence;
    
    public function __construct($sentence)
    {
        $this->sentence = $sentence;
    }
    
    public function greet($name)
    {
        spritnf($sentence, $name);
    }
}

$chainGreeter = new ChainGreeter();
$chainGreeter->add(new StringGreeter('Hello %s'));
$chainGreeter->add(new StringGreeter('Good morning %s'));
$chainGreeter->greet('John Doe');

@pavel-dohnal-momentumft I also thought it's a composite, because this is how usuall composites are implemented.

So in the end I came with 2 ideas.

Command where we can use just __invoke. So it feels almost like named closure.

class GreetCommand
{
    /**
     * @var Greeter[]
     */
    private $greeters;

    public function __construct(array $greeters = [])
    {
        $this->greeters = $greeters;
    }

    public function __invoke($name)
    {
        foreach ($this->greeters as $greeter) {
            $greeter->greet($name);
        }
    }
}

And simple Greeters, because it's just multiple Greeters anyway.

class Greeters
{
    /**
     * @var Greeter[]
     */
    private $greeters;

    public function __construct(array $greeters = [])
    {
        $this->greeters = $greeters;
    }

    public function greet($name)
    {
        foreach ($this->greeters as $greeter) {
            $greeter->greet($name);
        }
    }
}

What do you think? ;-)