FunctionDef | SuperCollider 3.14.0-dev Help

withDefaultValues	If set to false, no default values are appended // "a, b, c" { \|a = 9, b = 10, c\| a + b }.def.argumentString(withDefaultValues: false);
withEllipsis	If set to true, ellipsis characters (`" ... "`) are appended // "a = 9, b = 10 ... c" { \|a = 9, b = 10 ... c\| a + b }.def.argumentString(withEllipsis: true); // "a = 9, b = 10, c" { \|a = 9, b = 10 ... c\| a + b }.def.argumentString(withEllipsis: false);
asArray	If set to true, return the string for an array that represents all arguments. The other arguments are set to false. // "[a, b] ++ c" { \|a = 9, b = 10 ... c\| a + b }.def.argumentString(asArray: true);

.makeEnvirFromArgs

Get the Array of Symbols of the local variable names.

.makeFuncModifierString(modifier)

Return a string that can be interpreted as code for a new function which extracts the arguments from the receiver. This can be used to build a hygienic macro which returns a function with valid keyword arguments, instead of just anonymously forwarding the arguments, like in { |...args| func.valueArray(args) }.

For an implementation example Function: flop (as below).

Arguments:

modifier

A function to which a string is passed that represents the array of all arguments. It should return a string that can be interpreted.

// basic usage
f = { |x, y| x.squared + y.squared }; // a function
a = f.def.makeFuncModifierString({ |argString| "%.scramble".format(argString) });
a.interpret.value(4, 5)

// use as a macro: multichannel expansion like in flop
f = { |x, y = 1| if(x > 0) { 1 } { 0 } * y }; // some function
// generate the body of a function that has a free and yet undefined variable "func"
// -> "{ |x, y = 1| ([x, y]).flop.collect { |x| func.valueArray(x) } }"
a = f.def.makeFuncModifierString({ |str| str ++ ".flop.collect { |x| func.valueArray(x) }" });
// wrap that body into a function that takes "func" as argument and returns the function above
// now we have a valid code for a function:
// -> "{ |func| { |x, y = 1| [x, y].flop.collect { |x| func.valueArray(x) } } }"
b = "{ |func| % }".format(a);
// interpret the code to a function
g = b.interpret;
// pass the function f to g, which returns a function from a where "func" is bound to f
h = g.value(f);
// we can now use h in place of f, but all arguments are multichannel expanded:
f.([1, 0], [6, 7]); // does not work
h.([1, 0], [6, 7]); // [6, 0]
// and the new function supports the same keywords arguments:
h.(x: (-2..2), y: (-2..2));

// this functionality is implemented for function in the method "flop"
h = f.flop;
h.([1, 0], [6, 7]); // [6, 0]

FunctionDef : Object

.code

.sourceCode

.context

.findReferences(aSymbol, references)

.argNames

.prototypeFrame

.varNames

.argumentString(withDefaultValues: true, withEllipsis: false, asArray: false)

Arguments:

.makeEnvirFromArgs

.makeFuncModifierString(modifier)

Arguments:

.dumpByteCodes

.archiveAsCompileString

.asFunction

.checkCanArchive

.constants

.dumpContexts

.hasKwArgs

.hasPartialApplication

.hasVarArgs

.inspectorClass

.keyValuePairsFromArgs

.numArgs

.numVars

.selectors

.shallowCopy

.varArgs

.varArgsValue