typehinting traits

Hi Ferenc:

Hi Stefan,

Multiple people asked me that how they can expect/check that a given
object uses a trait or not.
Of course one could write the concrete methods as a trait and always use
a given interface for typehints, but I can't see why shouldn't instanceof
and typehints in general work for traits.
Is the any technical or maybe theoretical argument against this?

Originally I proposed traits including the semantics that traits directly
implement interfaces.

The discussion is somewhere here:
internals@lists.php.net/msg33935.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg33935.html

I think Sebastian was the person with the strongest opinion on that
particular issue:
internals@lists.php.net/msg33948.html" rel="nofollow" target="_blank">http://www.mail-archive.com/internals@lists.php.net/msg33948.html

And I tend to agree with him.

Currently I think along the following lines:

A trait is not a full unit of reuse!
A class is.
Don't use traits where you should use classes and composition.
Traits do not guarantee anything, if you want to be sure your invariants
hold, use classes and composition.

Traits allow to reuse behavior in a much more flexible way, but they do
not replace classes.

And, well, then there is this:
https://wiki.php.net/rfc/horizontalreuse#requiring_composing_class_to_implement_interface

That should make sure that people can use interfaces for the purpose
envisioned here.

For reference, there is also: https://bugs.php.net/bug.php?id=55613

But aside of the things I said before:

• theoretically: keeping interfaces and traits apart is a good, clean
  language design decision.
• practically: people LOVE ugly languages, because they get things done

So, well, I can't claim anything about value here.
The current situation might be more friendly to the teacher.
Another design might offer more freedom/power...

Thanks for the clarification.
Without either having the ability to check a trait or implement an
interface for a trait, or at least implementing the require syntax, I think
that it isn't really a non-fragile solution for my question.
AFAIK the only solution available currently is something like:

<?php
interface testTraitInterface{

}

trait testTrait{

}

class testClass implements testTraitInterface{
use testTrait;
}

$tc = new testClass;
var_dump($tc instanceof testTraitInterface);

Which is pretty weak of a solution, however if we only thinks traits as a
macro, this is enough, but then why bother with the as and insteadof, traits
composed traits and such?
I think we will have much more feedback with the release of 5.4, so maybe
we can re-consider extending the implementation for the next version.
And I agree that it is the best to only release what we are confident in,
and I'm happy that we waited a version for correctly implementing Closures
for objects.

Thanks again for the clarification and for your work on traits!

Jeff Carouth pointed out(
https://twitter.com/#!/jcarouth/status/126030715514138624) that we have
class_uses() (https://bugs.php.net/bug.php?id=55266), would be nice having
that in the documentation.

--
Ferenc Kovács
@Tyr43l - http://tyrael.hu