warning: D: multiply defined
warning: D: multiply defined
warning: C: multiply defined
warning: C: multiply defined
warning: B: multiply defined
warning: B: multiply defined
warning: A: multiply defined
warning: A: multiply defined
warning: D: multiply defined
warning: D: multiply defined
warning: C: multiply defined
warning: C: multiply defined
warning: B: multiply defined
warning: B: multiply defined
warning: A: multiply defined
warning: A: multiply defined

I was not troubled by this so far operating the patch of this, but still wondering what this is? Can this be resolved? Could this be causing a problem in the future?

There are some classes in Pd that use global symbols to send/receive messages.

Some of those classes assume there is only one object in the running Pd instance that has a particular symbol associated with it. If you define multiple objects with the same name from these classes, it will cause the objects to function improperly or, in some cases, for Pd to crash.

Such classes are:

• data structures. Each [struct] needs to have a unique name
• garrays. When you create a new array it needs to have a unique name.

So for example, if you create several different arrays from the "Put" menu and name them all "D" you'll get the warning.

Also note: this warning can happen if you put an array inside an abstraction and then create multiple instances of that abstraction.

Btw-- IMO this should be an error and not a warning. In Purr Data that would have the added benefit of linking to the array/struct/etc. that has the duplicated name. If someone wants to submit a feature request I'll make that change to Purr Data:

https://git.purrdata.net/jwilkes/purr-data/issues

Hey!, I've found my bug! thanks. I was using several duplicates of an abstraction that each one contains array 'A','B','C','D'.
But still in trouble of resolving this issue. how can I set each abstraction's arrays unique while creating multiple of this abstraction in a patch??

@dopamine.walkalong $0
Google it for "pdpatchrepo $0" and you will understand (might understand... not easy!).
Every patch and abstraction (not sub-patch....... beware) is given a unique value for $0.
Add $0 to the name....... like $0-D and problem solved.

But it can be difficult to use when you are passing messages, and you might need some more help later.
The above search should find solutions though (once you have your head wrapped around the concept).

Actually $1 is easier to deal with.
Give each copy of your abstraction an argument....... 1, 2, 3 etc.
$0 $1 $2 are concepts that you really will need to understand in Pd, and the effort put in will be rewarded.
I tied and probably failed miserably to explain it here...........https://forum.pdpatchrepo.info/topic/9774/pure-data-noob/4
Download "show_me_dollars.zip"
But read the post.
I think the description in that post is easier to understand than the patch.
I hope it helps.
There are other $ variable explanations that might help such as that from @mod ..........
https://forum.pdpatchrepo.info/topic/5724/dollar-signs-in-objects-and-messages
David.

@whale-av

"$0 can be used in any object as part of the name or the address, which means that a message cannot escape from the abstraction. A sub-patch like [pd my-subpatch] will be given the same number."

If I'm correctly following you, this quote from your post looks satisfying my need.?.?

@dopamine.walkalong Yes, it will work.
But it can be easier to give each abstraction an argument.... say a number ......
[abstraction 1]
[abstraction 2]
etc.
Because then you can easily send it a message. [send 2-receiver] will send to only [receive $1-receiver] the second abstraction.
With $0 you do not know the value of $0 in advance, so it can be hard to pass messages......
If you want to write to the array from outside the abstraction it will be very... very hard to do so using $0.
Even inside the abstraction $0 is slightly more difficult.
To get it into a message to write into an array $0-array you would need..
[$0)
|
[read something $1-array( ....... where the $1 is replaced by the value of $0 when $0 is banged.

$0 is great for passing messages between [send] and [receive] within an abstraction and knowing the messages will be contained within each abstraction.
If you want to communicate from outside an abstraction the given arguments $1 $2...etc. are the way to go.
Sorry to keep repeating myself, but this is a fundamental principle to grasp.
David.

I'm glad you pointing things out for me to understand. thanks much much:-)

@dopamine.walkalong There is also the possibility to use the $0 of the main patch inside the abstractions by using [abstraction $0 1], [abstraction $0 2] etc.

This way you can use the $0 of the main patch inside the abstraction as $1, for example [array define $1-$2-data], and you can access the arrays from the main patch like [array get $0-1-data].

The $0 would be used so you can open the main patch multiple times without conflicts.