Passing array of instruments to Pbind

Questions
1

Shouldn’t this work?

( 
Pbind(
    \instrument , Pseq([\foo, \foo1, \foo2, [\foo0, \foo1, \foo2]], inf),
    \dur        , 0.5,
).play; 
)

with other parameters Pbind will make a chord.
but with \instrument it throws an error:


-> an EventStreamPlayer
ERROR: Cannot convert this object to a SynthDef:  [ foo0, foo1, foo2 ]
Instance of Array {    (0x557915a8ad28, gc=E0, fmt=01, flg=00, set=02)
  indexed slots [3]
      0 : Symbol 'foo0'
      1 : Symbol 'foo1'
      2 : Symbol 'foo2'
}
ERROR: Message 'name' not understood.
RECEIVER:
   nil
ARGS:

PROTECTED CALL STACK:
	Meta_MethodError:new	0x557910c34540
		arg this = DoesNotUnderstandError
		arg what = nil
		arg receiver = nil
	Meta_DoesNotUnderstandError:new	0x557910c36880
		arg this = DoesNotUnderstandError
		arg receiver = nil
		arg selector = name
		arg args = [  ]
	Object:doesNotUnderstand	0x55790f6d1940
		arg this = nil
		arg selector = name
		arg args = nil
	a FunctionDef	0x557912348680
		sourceCode = "{ |instrument|
					var	synthLib, desc;
					// if user specifies a msgFunc, prefer user's choice
					if(~msgFunc.isNil) {
						instrument = ~instrument = instrument.asDefName;

						synthLib = ~synthLib ?? { SynthDescLib.global };
						desc = synthLib.at(instrument);
						if (desc.notNil) {
							~hasGate = desc.hasGate;
							~msgFunc = desc.msgFunc;
						} {
							~msgFunc = ~defaultMsgFunc;
						};
					} { ~msgFunc };
				}"
		arg instrument = [ foo0, foo1, foo2 ]
		var synthLib = nil
		var desc = nil
	a FunctionDef	0x557912356100
		sourceCode = "#{|server|
						var freqs, lag, strum, sustain;
						var bndl, addAction, sendGate, ids;
						var msgFunc, instrumentName, offset, strumOffset;

						// var schedBundleArray;

						freqs = ~detunedFreq.value;

						// msgFunc gets the synth's control values from the Event
						msgFunc = ~getMsgFunc.valueEnvir;
						instrumentName = ~synthDefName.valueEnvir;

						// determine how to send those commands
						// sendGate == false turns off releases

						sendGate = ~sendGate ? ~hasG...etc..."
		arg server = localhost
		var freqs = 261.6255653006
		var lag = nil
		var strum = nil
		var sustain = nil
		var bndl = nil
		var addAction = nil
		var sendGate = nil
		var ids = nil
		var msgFunc = nil
		var instrumentName = nil
		var offset = nil
		var strumOffset = nil
	a FunctionDef	0x5579123544c0
		sourceCode = "#{
					var tempo, server, eventTypes, parentType;

					parentType = ~parentTypes[~type];
					parentType !? { currentEnvironment.parent = parentType };

					server = ~server = ~server ? Server.default;

					~finish.value(currentEnvironment);

					tempo = ~tempo;
					tempo !? { thisThread.clock.tempo = tempo };


					if(currentEnvironment.isRest.not) {
						eventTypes = ~eventTypes;
						(eventTypes[~type] ?? { eventTypes[\\note] }).value(server)
					};

					~callback.value(current...etc..."
		var tempo = nil
		var server = localhost
		var eventTypes = ( 'fadeBus': a Function, 'freeAllocWrite': a Function, 'tree': a Function, 'instr': a Function, 
  'on': a Function, 'load': a Function, 'freeBuffer': a Function, 'group': a Function, 'freeAllocRead': a Function, 
  'allocWrite': a Function, 'cue': a Function, 'grain': a Function, 'Synth': a Function, 'freeAllocWriteID': a Function, 
  'alloc': a Function, 'rest': a Function, 'sine2': a Function, 'sine1': a Function, 'midi': a Function, 
  'set': a Function, 'setProperties': a Function, 'parGroup': a Functi...etc...
		var parentType = nil
	a FunctionDef	0x557912312e40
		sourceCode = "<an open Function>"
	Function:prTry	0x557910f75580
		arg this = a Function
		var result = nil
		var thread = a Routine
		var next = nil
		var wasInProtectedFunc = false
	
CALL STACK:
	DoesNotUnderstandError:reportError
		arg this = <instance of DoesNotUnderstandError>
	Nil:handleError
		arg this = nil
		arg error = <instance of DoesNotUnderstandError>
	Thread:handleError
		arg this = <instance of Thread>
		arg error = <instance of DoesNotUnderstandError>
	Thread:handleError
		arg this = <instance of Routine>
		arg error = <instance of DoesNotUnderstandError>
	Object:throw
		arg this = <instance of DoesNotUnderstandError>
	Function:protect
		arg this = <instance of Function>
		arg handler = <instance of Function>
		var result = <instance of DoesNotUnderstandError>
	Environment:use
		arg this = <instance of Event>
		arg function = <instance of Function>
		var result = nil
		var saveEnvir = <instance of Environment>
	Event:play
		arg this = <instance of Event>
	Event:playAndDelta
		arg this = <instance of Event>
		arg cleanup = <instance of EventStreamCleanup>
		arg mute = false
	EventStreamPlayer:prNext
		arg this = <instance of EventStreamPlayer>
		arg inTime = 24936.21024246
		var nextTime = nil
		var outEvent = <instance of Event>
	< FunctionDef in Method EventStreamPlayer:init >
		arg inTime = 24936.21024246
	Routine:prStart
		arg this = <instance of Routine>
		arg inval = 24934.71024246
^^ ERROR: Message 'name' not understood.
RECEIVER: nil
2

Pretty sure that isn’t supported. Here is an explanation from an older thread.

3

Ok, if nevertheless anyone wants to be able to do it this way
( like \instrument , Pseq([\foo, \foo1, \foo2, [\foo0, \foo1, \foo2]], inf))

following is example with Routine (or Prout)

		Routine ( { 
			instrumenNamesList.do{ arg it i;
				if(it.class == List, {
					it.do { |name|
						Synth(name);
					};
				}, {
					Synth(it);
				});
				
				durslist[i].wait;
			}  
		});

probably for better timing accuracy Synth objects should be replaced with OSC message bundles