Sure, I respect that. If you’re going to extend someone’s functions or types, it should keep to the same idea or structure. This isn’t type piracy, it’s punning off of some existing construct in a way that it was never intended. Using + for some non-commutative operation instead of * would be confusing.
The reason it’s not called type piracy is that it cannot cause the issue I showed above. Unless you commit type piracy somewhere, there’s no way to force me to use your code even if I did using PackageA. I still have to consent to use your functions or types. Type piracy takes away that consent. Without type piracy, if I don’t use types defined in your package then + is still commutative. With type piracy, you can make + for every other type non-commutative.
One of the things we specifically look for at METADATA reviews is type-piracy for this reason. We allow people to write bad code, but we do not allow their bad code to infect other people’s code. The meaning of type piracy is kept strict to “need to either own the functions or types” because it’s that combination which is required for this kind of infection to occur. Any less strict definition of type piracy is just mixing “writing bad code” with “writing infectious code” which dulls the meaning and dulls the severity of the issue.
Just call it a “bad pun” or something like that so it’s not confused with actual type piracy. Otherwise you’re extending the original idea of type piracy to include a case it was never intended to. The resulting confusion is irony at its best.