Yeah - title is the topic.
It feels like I went through a 1000 articles that describe the subject of using $0 in messages and what the work arounds are.
I am working on a patch, in which a signal is recorded in a wav.-file. This file is written to an existing table [$0-meight] via [tabwrite~ $0-meight]. Then, I want to read it out via [read -resize meightfile.wav $1-meight(. Then, stuff happens and in the end, I want to readout the file 8 times simultaneously with [tabread4~ $0-meight] with different pitches. But in the end, I always receive the mistake "0-meight: no such table" - I simply cannot figure out, how to solve this.
Everything works, as long there is no $0 included - but there would be problems, if i wanted to open the same abstraction multiple times in one patch. In the two screenshots, you can see what kind of (false) logic I tried to use, and how I created the table.

Does anybody have an advise for me, on how to solve this? I only can offer eternal gratefulness!

@Maggie17 $0 will be different in every abstraction. That is useful ...... making it local.
But if you want to look at it from another patch or abstraction you can't ...... the other abstraction doesn't know its value. It is looking for its own $0 value....... cannot find it...... hence the message.
Probably best to give your abstraction an argument........ [abstr 1]...... [abstr 2]..... and then use $1-meight for your table.
Then you will have 1-meight ........ 2-meight...... etc. and you will be able to read them from your other patches.
You can then use $0 ...... or $1 for messages inside your abstraction....... but always $1 if you want to send or receive a message from outside.

Of course..... if you put a [receive $1-mess] in a patch that has 5 as its first argument then if you want to send to it from another patch you must use [send 5-mess]..... and to use tabplay to read table $1-meight from outside the abstraction you will need to use [tabplay 5-meight].....
David.
P.S. the error you are seeing though, is coming from your second [read -resize........( message.
$0 has no meaning in a message box...... and becomes simply "0"....... and you don't have a table 0-meight...... although you could if you wish.
Your first part...... bang >> [$0] >> [message with $1( puts the value of $0 into the $1 in the message and is the correct way to get $0 into a message....... and will get $1 into a message too...... bang >> [$1] >> [message $1(

See this....... dollar.zip ..... small change made..
It is hard...... but great when you finally understand...... so worth the work.....

@whale-av Thanks a lot for your help!
Yeah, the whole abstraction, substitution, $# stuff is really not thaaat easy to understand... But thanks to your advise, I really learned something in this realm. That's some complicated stuff, but I start to understand it more and more.

Thank you very much!

Maggie

@Maggie17 You are welcome. You will get there, and do ask again if need be.
David.

@Maggie17 Sometimes it is easier with words........

Dollar $ variables in Pure Data patches.
A dollar variable is a thing that can be given a new value.
The new value can be a float or a symbol.

1. If the Dollar variable is in an [object] box
   A Pd patch can be saved and used inside another patch. We then call it an abstraction.... and it is just like a programming sub-routine.
   If you want to use it many times then you have a problem, that they are all the same, so if you put an object [receive woof] they will all receive any message that you send with [send woof].
   That might well be what you want to do.
   But what if you want to send the message to only one of them?
   You can give it an [inlet], but your patch will get messy, and what if your patch needs to make its own mind up about which abstraction it wants to send the message to, maybe depending on which midi note it received?
   The solution is to give the abstraction arguments... some parameters that define it and make it different to the other copies.
   For example [my_abstraction]
   Let’s give it some arguments [my_abstraction 5 9 woof]
   Inside the abstraction, as it is created (you open its parent patch) the dollar variables will be replaced. Wherever you see $1 written IN AN OBJECT it has been replaced by the number 5.
   Number 5 because 5 is the first argument and has actually replaced the $1. You still see $1, but if you bang a [$1] object it will output 5.
   [f $2] will output 9
   [symbol $3] will output woof
   So if you have an object [receive $1-$3] then it has now become [receive 5-woof]
   And if you want to send it a message from outside, from another patch or abstraction, you will need to use [send 5-woof]
   Every Pd patch, which remember includes your abstractions, also has a secret number. The number is unique and greater than 1000. As Pd opens each patch it gives it the number, increased by one from the last number it gave.
   That number will replace $0 as the patch is created. You can find out what the number is by banging a [$0] object and connecting its output to a number box, or [print] object.
   $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.
   But from outside your abstraction you don’t know what it will be when the patch is created, so it is not useful. (A lie, you can find out, but as it can change every time you open your patch it is not worth the bother).
   Use it to send messages within your patch [send $0-reset] to [receive $0-reset] for example, because the message is absolutely unique to its window, so you know it cannot interfere with other abstractions.
2. If the Dollar $ variable in a [message( box
   Dollar $ variables are also replaced, but not as the patch is created (drawn by Pd as you open it).
   Dollar zero $0 has no meaning in a message box. It will produce a zero if the message is banged, but that is it.
   It is a mistake, a patching error, to put a $0 in a message box.
   $1 $2 $3 $4 etc. in a message box are replaced by incoming atoms (individual floats or symbols or whatever) when they arrive. $1 will be replaced by the first atom in the list, $2 the second etc.
   So if you have a message box [$1 $2 $3( ..... and you send into it a list [3 48 lala( .....then it will output 3 48 lala
   That is not really very useful.
   But it is actually very powerful.
   Make a list in a message box........ [33 12 wav(
   And bang it into a message box [open my-track$2-$1.$3( and you will get the output.........
   open my-track12-33.wav
   Which could be just the message that you want to send to [soundfiler]

David.

@whale-av just tried to run your example from a folder called "$0" and the pure data console printed "mother_patch.pd: read failed; No such file or directory". every other folder name does work.

@Jona Interesting. I was not trying to address $0...... quite the opposite.
I just tried to show how arguments could be used to differentiate the abstractions.
Yes, Pd cannot find and open any patch that is in a folder called $0.
It must interpret $ variables in path names as well as filenames.
In a folder called $1 it prints "argument number out of range" exactly as it would for a dollar variable absent from a message. So as Pd opens a patch there is an internal message with the path and filename sent.
In extended the terminal is silent for $0....... just as it would be with $0 in a message.
So another rule to remember...... no $f in a path....

Except that now I have renamed my "bad-plugins" folder to bad-plugins$0" and I can be absolutely certain that no matter how I define valid paths in any version of Pd they will never be found....
Thank you for the tip...!
David.

@whale-av "I was not trying to address $0...... quite the opposite..." i know. perhaps i came up with that name because @Maggie17 was writing about 1000 articles about $0... thanks for the explanation of the pure data behaviour when one names patch folders with "$".