From 2b5318216ea6804a84920979fd77f759e35889fd Mon Sep 17 00:00:00 2001 From: Miller Puckette Date: Sun, 24 Jul 2005 19:41:15 +0000 Subject: New "list" object. Added "addcomma", "addsemi", "adddollar", "adddollsym" messages to message object. worked on Mac compilation problems. svn path=/trunk/; revision=3371 --- pd/doc/5.reference/list-help.pd | 364 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 364 insertions(+) create mode 100644 pd/doc/5.reference/list-help.pd (limited to 'pd/doc/5.reference') diff --git a/pd/doc/5.reference/list-help.pd b/pd/doc/5.reference/list-help.pd new file mode 100644 index 00000000..ea6355bb --- /dev/null +++ b/pd/doc/5.reference/list-help.pd @@ -0,0 +1,364 @@ +#N canvas 105 298 629 492 12; +#X obj 29 11 list; +#X text 352 455 updated for Pd version 0.39; +#X text 76 12 - building and using variable-length messages; +#N canvas 92 130 654 658 about-lists 0; +#X obj 50 625 print message; +#X msg 50 438 list x.wav 44100; +#X msg 50 596 read \$1 \$2; +#X msg 50 467 set x.wav 44100; +#X msg 67 567 set \, add2 read \, adddollar 1 \, adddollar 2; +#X msg 50 497 x.wav 44100; +#X obj 67 541 loadbang; +#X text 155 544 reset message as it was; +#X text 207 438 good; +#X text 196 469 bad; +#X text 46 25 Messages in Pd are simewhat artificially divided into +two classes. First are data-holding messages (bang \, float \, symbol +\, list) which are the primary way of communicating between objects. +Second is "everything else" (you could call them out-of-band messages +or metamessages) that describe changes in configuration \, read and +write files \, quit Pd \, etc. These are provided so that complex objects +don't need to have 100 separate inlets for every possible functionality. +It's not clear whether this was a good design choice \, but it's entrenched. +; +#X text 162 497 ugly; +#X text 48 183 The distinction becomes visible \, and ugly \, when +the leading item in a data-holding message is a symbol. In this case +\, to disambiguate it from the other sort \, the printed form of the +message has a selector \, "list" or "symbol" prepended to it. Underneath +\, there is always a selector in fromt of data messages \, but it is +implied if the first data item is a number.; +#X msg 411 461 list 44100 x.wav; +#X msg 424 486 44100 x.wav; +#X obj 411 512 print number-first; +#X text 405 433 these two are equivalent:; +#X text 50 294 In the example below \, the top message sets \$1 to +"x.wav" and \$2 to 44100 in the "read" message. The lower message box +outputs the message "read x.wav 44100". The "set" message changes the +content of the message box itself (click on the longer message box +below to repair the damage.) The "ugly" message \, since it is neither +"list" nor "set" \, gets interpreted in an arbitrary (and probably +inappropriate!) way.; +#X connect 1 0 2 0; +#X connect 2 0 0 0; +#X connect 3 0 2 0; +#X connect 4 0 2 0; +#X connect 5 0 2 0; +#X connect 6 0 4 0; +#X connect 13 0 15 0; +#X connect 14 0 15 0; +#X restore 42 311 pd about-lists; +#X text 33 52 There are four list classes:; +#X obj 22 82 list append; +#X obj 22 107 list prepend; +#X obj 22 157 list trim; +#X obj 22 132 list split; +#X text 140 81 - append the second list to the first; +#X text 141 108 - prepend the second list to the first; +#X text 141 133 - split a list in two; +#X text 141 160 - trim the "list" selector off; +#N canvas 186 284 602 409 trim 0; +#X msg 159 239 1 2 3; +#X msg 159 190 list cis boom bah; +#X msg 160 265 bang; +#X msg 159 163 walk the dog; +#X obj 134 341 list trim; +#X obj 134 363 print trim; +#X msg 160 287 1 x y; +#X msg 159 313 x 1 y; +#X text 29 19 trim - convert list to message \, using first item as +selector; +#X msg 159 213 55; +#X text 27 55 The "list trim" object inputs lists (or makes lists out +of incoming non-list messages) and outputs a message whose selector +is the first item of the list \, and whose arguments \, if any \, are +the remainder of the list. If the list has no items \, or if its first +item is numeric \, the selector is "list" (which might print out as +list \, float \, or bang.); +#X connect 0 0 4 0; +#X connect 1 0 4 0; +#X connect 2 0 4 0; +#X connect 3 0 4 0; +#X connect 4 0 5 0; +#X connect 6 0 4 0; +#X connect 7 0 4 0; +#X connect 9 0 4 0; +#X restore 506 160 pd trim; +#X text 501 53 details:; +#X text 499 36 click for; +#N canvas 322 170 608 420 append 0; +#X obj 17 324 list append 1 2; +#X floatatom 17 154 5 0 0 0 - - -; +#X msg 17 129 1 2 3; +#X msg 17 82 list cis boom bah; +#X msg 17 179 bang; +#X msg 176 294 bang; +#X obj 17 353 print append; +#X msg 17 39 walk the dog; +#X msg 176 244 list x y z; +#X msg 175 218 go dog go; +#X msg 174 268 4 5 6 and 7; +#X text 138 37 non-list message converted to list; +#X text 182 77 list starting with symbol; +#X text 181 96 (needs explicit "list" selector); +#X text 69 152 number is one-element list; +#X text 72 129 numeric list; +#X text 67 181 bang is zero-element list; +#X text 270 215 same for right inlet...; +#X text 286 267 (note: only the first item; +#X text 289 286 need be a number to make this; +#X text 289 304 a list.); +#X text 170 325 <- creation args initialize the list to append; +#X text 20 6 Append - append (concatenate) the second list to the first +; +#X connect 0 0 6 0; +#X connect 1 0 0 0; +#X connect 2 0 0 0; +#X connect 3 0 0 0; +#X connect 4 0 0 0; +#X connect 5 0 0 1; +#X connect 7 0 0 0; +#X connect 8 0 0 1; +#X connect 9 0 0 1; +#X connect 10 0 0 1; +#X restore 506 84 pd append; +#N canvas 391 326 667 561 split 0; +#X msg 103 328 1 2 3; +#X msg 79 231 list cis boom bah; +#X msg 99 263 bang; +#X obj 79 421 list split 2; +#X floatatom 182 396 3 0 5 0 - - -; +#X obj 79 469 print split1; +#X obj 198 470 print split2; +#X msg 79 204 walk the dog; +#X msg 102 306 1 2; +#X msg 100 285 1; +#X msg 103 349 1 2 3 4; +#X msg 103 372 1 2 so are you; +#X obj 320 470 print split3; +#X text 76 488 first n; +#X text 195 489 rest of list; +#X text 317 489 shorter than n; +#X text 218 394 new split point; +#X text 49 25 Split - cut a list into smaller ones; +#X text 210 419 <-- creation arg inits split point; +#X text 201 202 non-list message converted to list; +#X text 245 231 list with three symbols; +#X text 139 288 list with one number; +#X text 177 310 ... etc; +#X text 241 370 <- if the first item is a number \, it's a list.; +#X text 142 262 list with no items; +#X text 48 61 The "list split" object takes lists and outputs the first +"n" items (left outlet) and the remaining ones (middle outlet). The +two outputs appear in the usual right-to-left order. In case there +are fewer than "n" items in the list \, it is output (in its entirety) +from the third outlet instead. The creation argument or the inlet sets +the split point.; +#X connect 0 0 3 0; +#X connect 1 0 3 0; +#X connect 2 0 3 0; +#X connect 3 0 5 0; +#X connect 3 1 6 0; +#X connect 3 2 12 0; +#X connect 4 0 3 1; +#X connect 7 0 3 0; +#X connect 8 0 3 0; +#X connect 9 0 3 0; +#X connect 10 0 3 0; +#X connect 11 0 3 0; +#X restore 506 134 pd split; +#N canvas 0 0 640 478 prepend 0; +#X obj 17 324 list append 1 2; +#X floatatom 17 154 5 0 0 0 - - -; +#X msg 17 129 1 2 3; +#X msg 17 82 list cis boom bah; +#X msg 17 179 bang; +#X msg 176 294 bang; +#X obj 17 353 print append; +#X msg 17 39 walk the dog; +#X msg 176 244 list x y z; +#X msg 175 218 go dog go; +#X msg 174 268 4 5 6 and 7; +#X text 138 37 non-list message converted to list; +#X text 182 77 list starting with symbol; +#X text 181 96 (needs explicit "list" selector); +#X text 69 152 number is one-element list; +#X text 72 129 numeric list; +#X text 67 181 bang is zero-element list; +#X text 270 215 same for right inlet...; +#X text 286 267 (note: only the first item; +#X text 289 286 need be a number to make this; +#X text 289 304 a list.); +#X text 20 6 Prepend - prepend the second list to the first; +#X text 167 324 <- creation args initialize the list to prepend; +#X connect 0 0 6 0; +#X connect 1 0 0 0; +#X connect 2 0 0 0; +#X connect 3 0 0 0; +#X connect 4 0 0 0; +#X connect 5 0 0 1; +#X connect 7 0 0 0; +#X connect 8 0 0 1; +#X connect 9 0 0 1; +#X connect 10 0 0 1; +#X restore 506 109 pd prepend; +#X text 29 228 In general \, inlets that take lists (two each for append/prepend +\, and one each for split and trim) will convert non-list messages +(such as "set 5") to lists (such as "list set 5" automatically. Here's +more about lists in Pd:; +#X text 30 344 And here are some examples showing how to use these +objects to compose and/or use variable length messages:; +#N canvas 381 50 719 646 example1 0; +#X obj 43 173 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 252 176 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 247 154 clear; +#X text 40 153 send; +#X msg 91 175 250; +#X msg 123 175 500; +#X msg 156 175 750; +#X msg 189 175 1000; +#X obj 43 258 list append; +#X obj 208 220 t l; +#X obj 91 214 list prepend; +#X obj 43 426 t l l; +#X obj 94 426 print start; +#X obj 149 257 print stored; +#X obj 43 451 list split 1; +#X obj 43 575 del; +#X obj 43 607 print bang; +#X obj 75 542 list append; +#X msg 55 403 0 250 250 500; +#X text 118 150 -- add --; +#X text 57 20 example 1: simple rhythmic sequencer; +#X text 49 53 The top part of this patch demonstrates building up a +message from a variable number of elements provided sequentially. The +"list prepend" object stores the list and \, each time a number arrives +\, prepends the previous list to it.; +#X text 416 237 "list prepend" to its own inlet.; +#X text 253 220 "trigger list" is needed only to connect outlet of +; +#X text 274 258 printout shows the growing message.; +#X text 67 279 "list append" stores the growing message which is output +by the "send" button above. "list prepend" would have been equivalent. +; +#X text 185 403 <-- test message; +#X text 59 354 The bottom part of the patch takes numbers off the beginning +of the list \, one by one \, to use as delays.; +#X text 210 426 printout shows the sequence as it starts.; +#X text 189 543 The rest of the list is stored for next time.; +#X obj 161 505 print done; +#X text 170 450 Split off the first item. If there is none \, nothing +comes out the first or second outlet \, but instead we get a "bang" +from the third one.; +#X text 84 575 After delay \, output a bang and recall the rest of +the list.; +#X connect 0 0 8 0; +#X connect 1 0 10 1; +#X connect 4 0 10 0; +#X connect 5 0 10 0; +#X connect 6 0 10 0; +#X connect 7 0 10 0; +#X connect 8 0 11 0; +#X connect 9 0 10 1; +#X connect 10 0 9 0; +#X connect 10 0 8 1; +#X connect 10 0 13 0; +#X connect 11 0 14 0; +#X connect 11 1 12 0; +#X connect 14 0 15 0; +#X connect 14 1 17 1; +#X connect 14 2 30 0; +#X connect 15 0 16 0; +#X connect 15 0 17 0; +#X connect 17 0 14 0; +#X connect 18 0 11 0; +#X restore 221 397 pd example1; +#X text 64 396 simple sequencer; +#N canvas 126 39 568 569 example2 0; +#X obj 66 263 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 292 266 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 287 244 clear; +#X text 63 243 send; +#X obj 66 342 list append; +#X obj 213 317 t l; +#X obj 94 303 list prepend; +#X obj 66 410 t l l; +#X obj 121 410 print start; +#X obj 171 340 print stored; +#X obj 66 486 del; +#X obj 105 486 list append; +#X msg 94 264 250 57; +#X msg 154 264 500 52; +#X msg 215 264 750 55; +#X obj 66 461 unpack; +#X obj 66 435 list split 2; +#X text 80 38 example 2: sequencer with pitch; +#X text 147 242 -- add --; +#X obj 185 438 print done; +#X obj 115 517 print pitch; +#X text 13 69 This example is a slight modification of example 1 showing +how to build up lists with more than one item per iteration. We regard +pairs of numbers as specifying a delay time and a pitch. Unlike the +previous example \, the delay here is interpreted as teh delay until +the next event \, not the delay since the previous one. This is done +by taking the "pitch" output before the delay object (previously the +"output" was taken from the delay object's output.); +#X connect 0 0 4 0; +#X connect 1 0 6 1; +#X connect 4 0 7 0; +#X connect 5 0 6 1; +#X connect 6 0 5 0; +#X connect 6 0 4 1; +#X connect 6 0 9 0; +#X connect 7 0 16 0; +#X connect 7 1 8 0; +#X connect 10 0 11 0; +#X connect 11 0 16 0; +#X connect 12 0 6 0; +#X connect 13 0 6 0; +#X connect 14 0 6 0; +#X connect 15 0 10 0; +#X connect 15 1 20 0; +#X connect 16 0 15 0; +#X connect 16 1 11 1; +#X connect 16 2 19 0; +#X restore 221 423 pd example2; +#X text 55 425 another sequencer; +#X text 113 452 serializer; +#N canvas 116 31 673 426 example3 0; +#X obj 19 287 list split 1; +#X obj 19 378 print; +#X obj 19 204 until; +#X obj 19 242 list append; +#X obj 45 171 t b l; +#X obj 149 287 bang; +#X msg 45 148 1 2 3 4 a b c; +#X text 34 21 example 3: serializing a message without delays; +#X text 17 55 The "until" object can be used as shown to iterate through +all the items of a list.; +#X text 178 147 <- click to test; +#X text 101 171 First store list \, then start the loop; +#X text 118 199 "until" bangs its output until told to stop by a "bang" +to its right inlet.; +#X text 137 241 Store the remaining list.; +#X text 194 286 third outlet of "split" tells us to stop.; +#X text 67 318 Second outlet of "split" becomes the new list for "list +append" above.; +#X text 75 377 First outlet is the output.; +#X connect 0 0 1 0; +#X connect 0 1 3 1; +#X connect 0 2 5 0; +#X connect 2 0 3 0; +#X connect 3 0 0 0; +#X connect 4 0 2 0; +#X connect 4 1 3 1; +#X connect 5 0 2 1; +#X connect 6 0 4 0; +#X restore 220 450 pd example3; +#X obj 22 194 list; +#X text 70 195 - short for "list append"; -- cgit v1.2.1