Nil (./27) :
en fait, ma question sur les interfaces revenait à demander si on documentait deux fois, une fois pour l'interface et une fois pour l'implémentation

heu... ah, ok ^^

Si je reprend mes deux exemples de tout à l'heure, à première vue :
- Doctrine documente les méthodes dans implémentations, et pas dans l'interface (dans l'exemple reproduit plus haut, il y a un docblock au niveau "interface", mais pas au niveau des méthodes dans l'interface)
- ZF fait plus compliqué ; si je prend un exemple :

interface Zend_Server_Interface
{
...
    /**
     * Attach a class to a server
     *
     * The individual implementations should probably allow passing a variable
     * number of arguments in, so that developers may define custom runtime
     * arguments to pass to server methods.
     *
     * Namespacing is primarily for xmlrpc, but could be used for other
     * implementations as well.
     *
     * @param mixed $class Class name or object instance to examine and attach
     * to the server.
     * @param string $namespace Optional namespace with which to prepend method
     * names in the dispatch table.
     * methods in the class will be valid callbacks.
     * @param null|array Optional array of arguments to pass to callbacks at
     * dispatch.
     * @return void
     */
    public function setClass($class, $namespace = '', $argv = null);
...

...

et class Zend_Soap_Server implements Zend_Server_Interface
{
...
    /**
     * Attach a class to a server
     *
     * Accepts a class name to use when handling requests. Any additional
     * arguments will be passed to that class' constructor when instantiated.
     *
     * @param mixed $class Class name or object instance to examine and attach
     * to the server.
     * @param mixed $arg1 Optional argument to pass to class constructor
     * @param mixed $arg2 Optional second argument to pass to class constructor
     * dispatch.
     * @return Zend_Soap_Server
     * @throws Zend_Soap_Server_Exception if called more than once, or if class
     * does not exist
     */
    public function setClass($class, $arg1 = null, $arg2 = null)
    {

En gros, tu as dans l'interface des commentaires sur ce que doit faire la méthode, et à quoi correspondent les params / retours (ce qui correspond au rôle de l'interface, après tout), ainsi que des commentaires généraux sur ce que les implémentations pourraient faire.
Côté implémentation, tu as ce qui implémente l'interface qui est copié-collé (ce que fait la méthode, les params), et, éventuellement, une description spécifique

La solution Zend est la plus complète, mais la plus lourde à maintenir.
Perso, j'ai l'habitude de commenter au max l'interface, pour que ceux qui l'implémenteront sâchent quoi faire, mais je ne copie-colle généralement pas quand j'implémente : je ne met dans mon implémentation que ce qui est spécifique à l'implémentation... (mais après, je ne sais pas ce que ça donne en termes de type-hint et de phpdoc ^^ )