Como substituir a função de característica e chamá-la da função substituída?

Cenário:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    use A;

    function calc($v) {
        $v++;
        return A::calc($v);
    }
}

print (new MyClass())->calc(2); // should print 4

Esse código não funciona e não consigo encontrar uma maneira de chamar uma função de característica como se fosse herdada. Tentei ligar self::calc($v), static::calc($v), parent::calc($v), A::calc($v)e o seguinte:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    use A {
        calc as traitcalc;
    }

    function calc($v) {
        $v++;
        return traitcalc($v);
    }
}

Nada funciona.

Existe uma maneira de fazê-lo funcionar ou devo substituir completamente a função de característica que é muito mais complexa do que isso :)

Seu último estava quase lá:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    use A {
        calc as protected traitcalc;
    }

    function calc($v) {
        $v++;
        return $this->traitcalc($v);
    }
}

A característica não é uma classe. Você não pode acessar seus membros diretamente. É basicamente apenas copiar e colar automaticamente ...

Se a classe implementar o método diretamente, não usará a versão de características. Talvez o que você está pensando é:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    function calc($v) {
        return $v+2;
    }
}

class MyChildClass extends MyClass{
}

class MyTraitChildClass extends MyClass{
    use A;
}

print (new MyChildClass())->calc(2); // will print 4

print (new MyTraitChildClass())->calc(2); // will print 3

Como as classes filho não implementam o método diretamente, elas primeiro usarão a característica, caso contrário, a classe pai.

Se você quiser, a característica pode usar o método na classe pai (supondo que você saiba que o método estaria lá), por exemplo

trait A {
    function calc($v) {
        return parent::calc($v*3);
    }
}
// .... other code from above
print (new MyTraitChildClass())->calc(2); // will print 8 (2*3 + 2)

Você também pode fornecer maneiras de substituir, mas ainda acessar o método de característica da seguinte maneira:

trait A {
    function trait_calc($v) {
        return $v*3;
    }
}

class MyClass {
    function calc($v) {
        return $v+2;
    }
}


class MyTraitChildClass extends MyClass{
    use A {
      A::trait_calc as calc;
    }
}


class MySecondTraitChildClass extends MyClass{
    use A {
      A::trait_calc as calc;
    }

    public function calc($v) {
      return $this->trait_calc($v)+.5;
    }
}


print (new MyTraitChildClass())->calc(2); // will print 6
echo "\n";
print (new MySecondTraitChildClass())->calc(2); // will print 6.5

Você pode vê-lo funcionar em http://sandbox.onlinephpfunctions.com/code/e53f6e8f9834aea5e038aec4766ac7e1c19cc2b5

Uma abordagem alternativa, se estiver interessado - com uma classe intermediária extra para usar a via OOO normal. Isso simplifica o uso com parent :: methodname

trait A {
    function calc($v) {
        return $v+1;
    }
}

// an intermediate class that just uses the trait
class IntClass {
    use A;
}

// an extended class from IntClass
class MyClass extends IntClass {
    function calc($v) {
        $v++;
        return parent::calc($v);
    }
}

Usando outra característica:

trait ATrait {
    function calc($v) {
        return $v+1;
    }
}

class A {
    use ATrait;
}

trait BTrait {
    function calc($v) {
        $v++;
        return parent::calc($v);
    }
}

class B extends A {
    use BTrait;
}

print (new B())->calc(2); // should print 4