How to enforce matching, but unknown interfaces

With @caleth pointing me in the right direction and some more research, I think I can answer my own question like this:

I think in general, the problem seems to be made for generics. Since PHP doesn't support generics, I'll need to leave out real generic TypeHints. Instead I'll document the right types using the @template T (with @var T and @return T and so on...) annotations. Moreover I'm considering integrating some kind of static analysis tool like PHPStan to provide some ability to check the correct types as in JAVA a compiler would do.

So, my code looks like this now:

/**
* @template T of DataInterface
*/
class Client {
    /** @var EvaluatorInterface<T> */
    private $evaluatorStrategy;
    /** @return T */
    public function getData() {
     //return data...
    }
    public function doEvaluation()
    {
        $value = $this->evaluatorStrategy->evaluate($this->getData());
        //...
    }
}

The whole idea of an Interface is that it is a contract which tells the caller what is expected. Allowing any interface is usually consider a bad idea, because:

1. If any object type to allowed to be passed in, reflection is required to find the methods and properties, but even if that was done, foreknowledge of how to use them is required.
2. Weakly typed languages like JavaScript, do this all the time. If they want to append something to an object they just do it. We are able to use this pattern in Strongly typed languages but it does not diminish the foreknowledge factor.
3. The newer patterns for Strongly typed languages bring the Generic factor.

// Allows any type to be passed in as a parm
public method<ofType>(ofType parm1){
  //still requires knowledge of how to use.       
}

4. The traditional pattern is to protect our code as follows. In this pattern we are saying if you want to use this method there's only these interfaces that we support.

//Only allow known interface implementations
public method(InnterfaceTypeA NameA){ //we know this interface }
public method(InnterfaceTypeB NameB){ //we know this interface }
public method(InnterfaceTypeC NameC){ //we know this interface }

5. This pattern uses the keyword Dynamic (which C# has)

 //Still requires discovery of the type and how to use it.
 public method(Dynamic Parma){}

I am a bit out-of-touch with PHP, so I'll give it for java. It is reminiscent of OpenGL/DirectX discovery of capabilities; which was not done systematically.

My Solution

What you want, is the detection of (yet unknown) capabilities.

Every capability is an interface.

public class Client {
    public <T> Optional<T> lookup(Class<T> capability) { ... }
}

public interface Flying {
    /* @return average speed */
    int flyDistance(int distance);
}

public interface Swimming {
    /* @return average speed */
    double swimDistance(double weight);
}

Client client = new BirdClient();
client.lookup(Flying.class)
    .ifPresent(flying -> System.out.printf("Avg speed: %f%n",
                               flying.flyDistance(50)));

In PHP instead of Optional null etcetera.

Reason

The evaluation needs structured data, specific to the evaluation class. The classes are open ended.

If you would have the evaluation class in the client as a very general class, you still would not have the data interface appliable on the world data.

So you must start with the specific class (Flying/Swimming), and then ask the client whether it can do that.

You might also be more open, have 2 evaluation strategies for a client, old and new, or on for other aspects, time and money.

And the other reason: this is evaluation centric; you start with the processing: the evaluation: as interface. And then you tailor your client as such. It is much less obvious if you have a "data object" and therein have to store the data object for this evaluation strategy, and so on, swimming in muddy waters.