Duda con funcionamiento y organización de Traits

[guardarmicorreo]

:) creía que me había quedado claro, pero veo que no.

Italico76 dijo que los Traits se pueden evitar desacoplando en mayor medida las clases, cosa que creo que es discutible y que no tienen mucho que ver una cosa con la otra.

Pero en general entendí que los Traits, por muy útiles que sean, no están contemplados en el futuro de la mayoría de lenguajes porque es algo que lleva a crear código dañino a la vista (como el mío :D ).

Pero ahora llegais hhs y dashtrash y le dais un nuevo enfoque. Fascinante :D

vamos a ver si me entero sobre código

Esto sería la herencia simple en PHP

Código PHP:

<?php
 
abstract class A {
 
    public static function saymethodsA() {
        return get_class_methods('A');
    }
 
}
 
class B extends A {
 
    public function printmethods() {
        ?>
        <pre>
        <?php
        var_dump(parent::saymethodsA());
    }
 
}
 
B::printmethods();
/*
 * imprime
 * 
   array(1) {
    [0]=>
    string(11) "saymethodsA"
   }
 * 
 */
 

Esto es el uso de Traits para simular la herencia múltiple solucionando ciertos problemas que conlleva la herencia múltiple como tal.

Código PHP:

abstract class E {
 
    public static function saymethodsE() {
        return get_class_methods('C');
    }
 
}
 
Trait coreEF{
    public static function saymethods($class){
        return get_class_methods($class);
    }
}
 
class F{
    use coreEF;
}
 
?>
<pre>
<?php
var_dump(F::saymethods('A'), F::saymethods('B'), F::saymethods('E'), F::saymethods('F'));
 
/*
 * imprime
 */
//array(1) {
//  [0]=>
//  string(11) "saymethodsA"
//}
//array(2) {
//  [0]=>
//  string(12) "printmethods"
//  [1]=>
//  string(11) "saymethodsA"
//}
//array(1) {
//  [0]=>
//  string(11) "saymethodsE"
//}
//array(1) {
//  [0]=>
//  string(10) "saymethods"
//}
 

¿Cómo se podría resolver el problema de los Traits desacoplando las clases unas de otras?

(Entiendo desacoplar como la estrategia de componer/construir/escribir clases de manera que unas dependan de las otras lo menos posible)

A mi solo se me ocurren dos posibilidades y no estoy seguro de la segunda:

1) metiendo en clases funcionalidades que no guardan relación entre si, por lo tanto se estaría rompiendo lo que es el concepto de POO.

2) utilizando los namespaces de manera tal que dentro de las propias clases se utilicen otras clases.

EDITO:

hhs no me confundas más!! jaja que me costó mucho entender la gran enorme diferencia entre interfaz (algo raro que no entiendo su utilidad relevante) y el resto de código ejecutable y útil, como clases y traits :D