Hello!

Question for you savvy patchers!
I'm building a small granular synth, using the [clone] object to make multiple copies of a grain-abstraction. In the grain-abstraction I'm using a [tabread4~] to read a soundfile from an array. If the grain-abstraction is saved with a "$0-grain" as its [tabread4~]-array reference, and called from [clone] with 16 instances, pd makes 16 unique identifiers for the "$0-grain" reference, making it impossible to reference an array outside the abstraction.
Does anyone have a solution to this? Is it even possible to work around?

@differencetones Use the clone number instead........ $1-grain.
It will start at 0 unless you specify a different start number using the -s switch.
So normally for 16 clones the $1 values will be 0-15.
If you will have another set of 16 clones of the same abstraction then you can add another argument to each set........ say 1 and 2.......... and then use $2-$1-grain for the array (translated 1-12-grain for example for the sender) to send to the clones.

Something like this........ eg.zip
David

@differencetones you can just parse $0 as an argument to clone like this:
[clone myabstraction 16 $0]
To refer to $0-grain in the parent, use [tabread4~ $2-grain] inside your abstraction ($1 is the number of the clone instance)

Thanks!
Yes, using [tabread4~$2-grain] in the abstraction and naming clone [clone grain 16 $0] works! However, this has to be associated with an array with "$0-" in its name, see the screenshot - where pd throws up an error of "0-array: no such table". If I change the read... message and the array to "grain" load a file and rename to $0-grain, it works. But I cannot load a file into the array when named $0-grain.
Any ideas?

@differencetones $0 will not be resolved in messages. $-variables in messages work differently than in objects.

You can use:
[o]
|
[openpanel]
|
[list $0]
|
[read -resize $1 $2-array(
|
[soundfiler]

Yes! Perfect, thanks!

@ingox That is true.
It will work if the [openpanel] is inside the cloned abstraction.
But $0 in each cloned array name is going to be a different value from that of the container patch..... and they can change on reopening the patch containing the clone if other patches are open.
The only way I can think of to reference the $0 array name from outside is to grab the $0 values from the clones and modify the [soundfiler] message accordingly....... referencing the current value.
It can be done but will need some feedback from the clone as the sound file is loaded.
@differencetones Why do you absolutely need $0 in the array name?
Try this...... eg2.zip if you need to reference the clone from outside using its $0 value.
David.

@whale-av $0 is mostly used to guaranty locality in case a patch is opened multiple times, so there is no collision between used names.

Another way to tackle this is to use the $0 of the main patch throughout, hand it down to abstractions and clones and there use counting numbers for the individual clones/abstractions.

So for abstractions:
[abstraction $0 1], [abstraction $0 2] and so on
and inside:
[array define $1-$2-array].

For clones:
[clone abstraction 16 $0]
and inside:
[array define $2-$1-array].

You can then even access the clones/abstractions from outside because you know $0 already. In the mainpatch:
[array get $0-1-array] for example.

@ingox Yes but not using a literal $0 in the array name inside the clone and accessing it from outside as in the op.
"However, this has to be associated with an array with "$0-" in its name, see the screenshot -"
David.