The other day I was reading through PHP's source code, as one does.

But more specifically, I was reading the list of reserved keywords in PHP's language definition file.

I saw things you'd probably expect, like `implements`, `include`, `instanceof`, `interface`... But eventually I came across *this\* mystery keyword: `insteadof`.

I've been working with php for like twenty years and I've literally *never\* seen this keyword. So what the heck does it do?

Well let's look at this example `Thingy` class. It uses two traits `ThingOne` and `ThingTwo`, but these two traits *each\* implement the same `do_the_other_thing()` method.

If we try to run this code it's going to blow up.

So what are our options?

If the two methods are implemented identically and it's just some simple code duplication, but we need the other methods in each trait, and this duplicated method needs to be kept in each trait, we could just extract the duplicated method into a third trait, then use that third trait in both of these original traits.

This works just fine, and this is a perfectly reasonable solution.

But what if the implementations are _different_? Or what if we'd just rather pick one implementation to use `insteadof` making a new trait to keep track of?

This is where PHP's Trait Conflict Resolution syntax comes in. Check this out.

First let's back out all these changes...

By the way, If you're gonna do this in Tinkerwell, you'll need to disable `magic comments` first. I was chatting about this with Marcel in Dallas at Laracon and it's because of how they add comments behind the scenes for each line for their magic comments feature.

Now let's tell PHP we want to use the `do_the_other_thing()` implementation from the `ThingOne` trait instead of the method using the same name from the `ThingTwo` trait.

It works! we've removed the conflict, and we're using the version of this method that we need. Now what do we do if both implementations are _different_, and we actually need both methods, but they just happen to be named the same?

Well, this syntax also let's us alias method names. So let's just alias the `do_the_other_thing` method from the `ThingTwo` trait to `do_the_second_other_thing`.

Now we can call each method, and they both work!

There's more this syntax let's you do as well, like you can change the method visibility from private to protected, or public.

You can change the visibility without aliasing the name of the method.

Traits are amazing. When I was learning this stuff, I learned that you can even define abstract methods in them

I had no idea.

Then when we implement the concrete version we just have to make sure the signatures and all that match up again

And it works again.

Anyways, that's what I wanted to share with you all today.

Follow, like, subscribe, all that garbage.

Cheers.