Function : AbstractFunction : Object

The global pseudo-variable thisFunction always evaluates to the current enclosing Function.

See also: thisFunctionDef

Get the definition ( FunctionDef ) of the Function.

returns true if the function is closed, i.e. has no external references and can thus be converted to a compile string safely.

Evaluates the FunctionDef referred to by the Function. The Function is passed the args given.{ |a, b| (a * b).postln }.value(3, 10); { arg a, b; (a * b).postln }.value(3, 10); // different way of expressing the same

Evaluates the FunctionDef referred to by the Function. If the last argument is an Array or List, then it is unpacked and appended to the other arguments (if any) to the Function. If the last argument is not an Array or List then this is the same as the 'value' method.{ |a, b, c| ((a * b) + c).postln }.valueArray([3, 10, 7]); { |a, b, c, d| [a, b, c, d].postln }.valueArray([1, 2, 3]); { |a, b, c, d| [a, b, c, d].postln }.valueArray(9, [1, 2, 3]); { |a, b, c, d| [a, b, c, d].postln }.valueArray(9, 10, [1, 2, 3]);

A common syntactic shortcut:{ |a, b, c| ((a * b) + c).postln }.value(*[3, 10, 7]);

As value above. Unsupplied argument names are looked up in the current Environment.( Environment.use({ ~a = 3; ~b = 10; { |a, b| (a * b).postln }.valueEnvir; }); )

Evaluates the FunctionDef referred to by the Function. If the last argument is an Array or List, then it is unpacked and appended to the other arguments (if any) to the Function. If the last argument is not an Array or List then this is the same as the 'value' method. Unsupplied argument names are looked up in the current Environment.

Evaluate the function, using arguments from the supplied environment. This is slightly faster than valueEnvir and does not require replacing the currentEnvironment.( e = Environment.make({ ~a = 3; ~b = 10 }); { |a, b| (a * b) }.valueWithEnvir(e); )

For Function, this behaves the same as valueArray(arglist). It is used where Functions and other objects should behave differently to value, such as in the object prototyping implementation of Environment.

a = { |a, b, c| postf("% plus % plus % is %\n", a, b, c, a + b + c); "" }; a.performWithEnvir(\value, (a: 1, c: 3, d: 4, b: 2));

Arguments:

a = { |a, b, c| postf("% plus % plus % is %\n", a, b, c, a + b + c); "" }; a.performKeyValuePairs(\value, [\a, 1, \b, 2, \c, 3, \d, 4]);

Arguments:

Repeat this function. Useful with Task and Clocks.t = Task({ { "I'm loopy".postln; 1.wait;}.loop }); t.start; t.stop;

Delay the evaluation of this Function by delta in seconds on AppClock.

This is equivalent to AppClock.sched(0, function) unless delta is nil. In that case the function is only scheduled if current code is not running on AppClock, otherwise the function is evaluated immediately.{ "2 seconds have passed.".postln; }.defer(2); ( { "chicken".postln }.defer(0); // schedules on the AppClock { "egg".postln }.defer // evaluates immediately ) ( fork { // schedules on a TempoClock { "chicken".postln }.defer // schedules on the AppClock }; { "egg".postln }.defer // evaluates immediately )

Return an Array consisting of the results of n evaluations of this Function.x = { 4.rand; }.dup(4); x.postln;

equivalent to dup(n)x = { 4.rand } ! 4; x.postln;

return the sum of n values produced.{ 4.rand }.sum(8);

evaluates the function. This makes it polymorphic to SequenceableCollection, Bag and Set.[{ 100.rand }, [20, 30, 40]].collect(_.choose);

Returns the amount of time this function takes to evaluate. print is a boolean indicating whether the result is posted. The default is true.{ 1000000.do({ 1.0.rand }); }.bench;

Returns a Routine using the receiver as it's function, and plays it in a TempoClock.{ 4.do({ "Threading...".postln; 1.wait;}) }.fork;

If needed, creates a new Routine to evaluate the function in, if the message is called within a routine already, it simply evaluates it.f = { 4.do({ "Threading...".postln; 1.wait;}) }; f.forkIfNeeded; { "we are now in a routine".postln; 1.wait; f.forkIfNeeded }.fork;

Break from a loop. Calls the receiver with an argument which is a function that returns from the method block. To exit the loop, call .value on the function passed in. You can pass a value to this function and that value will be returned from the block method.block {|break| 100.do {|i| i.postln; if (i == 7) { break.value(999) } }; }

Return a Thunk, which is an unevaluated value that can be used in calculationsx = thunk { 4.rand }; x.value; x.value;

Return a function that, when evaluated with nested arguments, does multichannel expansion by evaluating the receiver function for each channel. A flopped function responds like the "map" function in languages like Lisp. The new function always returns an array.// multichannel expansion for if, here to protect from division by zero: f = { |a, b| if(b != 0) { a / b } { 0 } }.flop; f.value([1, 2, 3, 4], [0, 10, 1000]); // -> [ 0, 0.2, 0.003, 0 ] f.value(2, 4); // [ 0.5 ] (always returns an array) // strings don't expand f = { |a, b| a + b }.flop; f.("hello", ["world", "algorithm"]); // -> [ hello world, hello algorithm ] f.("hello", "world"); // -> [ hello world ]

Same as flop, return only an array if the arguments also contains an array. This can be used to implement Multichannel Expansion.// multichannel expansion for if, here to protect from division by zero: f = { |a, b| if(b != 0) { a / b } { 0 } }.flop1; f.value([1, 2, 3, 4], [0, 10, 1000]); // -> [ 0, 0.2, 0.003, 0 ] f.value([2], 4); // -> [0.5] f.value(2, 4); // -> 0.5 // strings don't expand, like in flop f = { |a, b| a + b }.flop1; f.("hello", ["world", "algorithm"]); // -> [ hello world, hello algorithm ] f.("hello", "world"); // -> hello world

This method is kept for backward compatibility. Use flop instead.

returns an "environment-safe" function. See Environment for more details. Note that the function returned takes no keyword arguments.e = (a: "get it", b: "didn't"); f = { ~b + ~a + "..." }.inEnvir(e); f.value; f = { |how = "", end = "..."| how + ~b + ~a + end }.inEnvir(e); // doesn't work with keyword arguments f.value(how: "really"); // WARNING: keyword arg 'how' not found in call to function (see inEnvirWithArgs). // a use case: defer is usually called in the call environment // prints nil because ~a is read from topEnvironment, not e e = (a: "got it", f: { { ~a.postln }.defer(0.5) }); e.use { e.f }; // prints "got it" because { ~a.postln } is now bound to the e environment e = (a: "got it", f: { { ~a.postln }.inEnvir.defer(0.5) }); e.use { e.f };

Like inEnvir, but returns a function which takes keyword arguments. Building this function makes a call to the interpreter and is less efficient than inEnvire = (a: "get it", b: "didn't"); f = { |how = "", end = "..."| how + ~b + ~a + end }.inEnvirWithArgs(e); f.value(how: "I really", end: "done!");

Function implements a case method which allows for conditional evaluation with multiple cases. Since the receiver represents the first case this can be simply written as pairs of test functions and corresponding functions to be evaluated if true. Unlike Object-switch, this is inlined and is therefore just as efficient as nested if statements.( var i, x, z; z = [0, 1, 1.1, 1.3, 1.5, 2]; i = z.choose; x = case { i == 1 } { \no } { i == 1.1 } { \wrong } { i == 1.3 } { \wrong } { i == 1.5 } { \wrong } { i == 2 } { \wrong } { i == 0 } { \true }; x.postln; )

Interface shared with other classes that implements pattern matching. See also: matchItem. Function.matchItem evaluates the function with the item as argument, expecting a Boolean as reply.

See also matchItem.{ |x| x > 5 }.matchItem(6); // true

use a function as a conversion from scale degree to note number. See also SequenceableCollection and Scale// a strange mapping ( var f = {|degree, stepsPerOctave, acc| (1.8 ** (degree % stepsPerOctave) + acc).postln }; Pbind( \scale, f, \degree, Pseq([0, 1, 2b, 3s, 4s, 6, 14, [0, 2, 4], [1, 3, 6]], inf) ).play )

Executes the receiver. If an exception is thrown the catch function handler is executed with the error as an argument. handler itself can rethrow the error if desired.

Executes the receiver. The cleanup function handler is executed with an error as an argument, or nil if there was no error. The error continues to be in effect.

This method is called by a Clock on which the function was scheduled when its scheduling time is up. It calls -value, passing on the scheduling time in beats as an argument.

Arguments:

Returns:

Play a Synth from UGens returned by the function. The function arguments become controls that can be set afterwards.

This works as follows: play wraps the UGens in a SynthDef and sends it to the target. When this asynchronous command is completed, it creates one synth from this definition.

Arguments:

As play above, and calls Server-scope to open a scope window in which to view the output.{ FSinOsc.ar(440, 0, 0.3) }.scope(1)

Arguments:

Calculates duration in seconds worth of the output of this function asynchronously, and plots it in a GUI window. Unlike play and scope it will not work with explicit Out Ugens, so your function should return a UGen or an Array of them. The plot will be calculated in realtime.{ SinOsc.ar(440) }.plot(0.01, bounds: Window.screenBounds); { {|i| SinOsc.ar(1 + i)}.dup(7) }.plot(1);

Arguments:

Calculates duration in seconds worth of the output of this function asynchronously, and returns it in a Buffer of the number of channels. This method immediately returns a buffer, which takes duration seconds to become filled with data asynchronously. Then the action function is called.

Arguments:

Discussion:

Write a UGen function to a file and then load it into a FloatArray.

Arguments:

Stream the function audio values to the client using a series of getn messages and put the results into a FloatArray.

Arguments:

Discussion:

For a discussion of the difference between getToFloatArray and loadToFloatArray, see Buffer: -getToFloatArray and Buffer: -loadToFloatArray.// get some data from the synth audio { SinOsc.ar + GrayNoise.ar(0.1) }.getToFloatArray(0.01, action: { arg array; a = array }); a.postln; a.plot;

Returns a SynthDef based on this Function, adding a Linen and an Out ugen if needed.

Arguments:

Performs asSynthDef (see above), sends the resulting def to the local server and returns the SynthDefs name. This is asynchronous.x = { SinOsc.ar(440, 0, 0.3) }.asDefName; // this must complete first y = Synth(x);

Returns a Routine using this as its func argument.

Returns a Routine using this as its func argument.a = r { 5.do { |i| i.rand.yield } }; a.nextN(8);

Returns a Prout using this as its func argument.a = p { 5.do { |i| i.rand.yield } }; x = a.asStream; x.nextN(8);

This is useful for using ListComprehensions in Patterns:Pbind(\degree, p {:[x, y].postln, x<-(0..10), y<-(0..10), (x + y).isPrime }, \dur, 0.3).play;

Like Function: -scope, plays and scopes this Function, but using Bela's Oscilloscope (see BelaScope for required setup). This Function's output bus is monitored right after the generated Synth.

Arguments:

Returns: