haha

why is it that I tried to keep my abstractions output in te right left order when they work fine outputting on any?

it makes it easier to understand. if abstractions and objects follow the same conventions, then you don't have to individually check each one to see which order has been used.

imagine a book in which some parts are written left->right, while other parts are written right->left. it would confuse the daylight out of you. much easier just to have things all conforming to a standard in this case.

lets say though you have on your main patch duplicated a process in different places , instead of clobbering up your main patch you put that process into an abstraction and the abstraction could have at anytime input or output on any of it's inlets and outlets. conforming to a right left order in this situation could mess things up as well as complicate the process.

comes down to style then

It's not an issue of messiness, it's an issue of usability and intuitiveness. If you don't intend on sharing your patches at all, then of course you can do whatever the hell you want. But if you share a patch that works differently than established Pd practices, then you better have a really good reason for it. Otherwise, the patch will be unintuitive. People will be required to alter the patching approaches they've grown accustomed to to specifically suit your abstractions.

The description you give, however, sounds more like a situation in which right-to-left order doesn't matter, because it sounds like you are talking about multiple hot inlets and outlets that aren't dependent on each other. It even sounds like you are talking about an abstraction that (perhaps) includes multiple processes. While these are more complicated situations, it is not at all impractical to conform to the convention.

As far as inlets are concerned, right-to-left order is meant for situations where you have hot and cold inlets. The cold inlets should be set first before sending a value or message to the hot inlet. If one cold (A) inlet depends on another cold inlet (B), then B should be set first and should be to the right of A (though it's not difficult to internally prevent that need, and you probably should). If you need multiple hot inlets, then the order of those inlets probably doesn't matter, but they should be to the left of the cold inlets. The only time the order of hot inlets would matter is if one depended on the other, but if that's the case, it's a bad design that can easily lead to errors. That inlet that should take it's value first should actually be a cold inlet.

With outlets, it really only matters in situations where each outlet should be sent at the same time. In that case, right-to-left is necessary, because they may be patched into a more convention object (or set of objects) in which the right-to-left inlet order is enforced. If they don't need to be sent out at the same time, then it probably doesn't matter.

thanks .mmb for the explanation. for some odd reason the idea of multiple hot inlets and outlets sliiped my mind or something till the other day when i was tidy'n up a patch and I hust copied and pasted a chunk from the main patch and put it in an abstraction. hen I thought about the abstraction with multiple hots I had to make a little GOP abstraction with inlets, and outlets to check to make sure I wasn't dreaming.

[inlet] [inlet]
| |
| [tgl] | [tgl]
| | | |
[spigot] [spigot]
| |
[outlet] [outlet]

something like that would sure help to simplify your patch if needed
i haven't actually needed that particular patch but it's good to know it works