Dictionary : Set : Collection : Object

Creates a Dictionary with an initial capacity for n key value mappings.

Creates a new Dictionary from another collection.d= Dictionary.newFrom([\a, 1, \b, 2, \c, 4]);

xxxxxxxxxx

d= Dictionary.newFrom([\a, 1, \b, 2, \c, 4]);

Arguments:

Discussion:

A new Dictionary can also be created from an array of Associations:Dictionary.with(*[\a->1,\b->2,\c->3])

xxxxxxxxxx

Dictionary.with(*[\a->1,\b->2,\c->3])

Or from a single Association like:d = Dictionary[\a -> 1];

xxxxxxxxxx

d = Dictionary[\a -> 1];

Add anAssociation to the Dictionary. If the key value pair already exists in the Dictionary, the key's value will be replaced.( d = Dictionary.new; d.add(\monkey -> 0).postln; d.add(\robot -> 1).postln; // Add robot as a key with a value of 1 d.add(\monkey -> 2).postln; // Replaces the value for the key monkey with 2 )

xxxxxxxxxx

(

d = Dictionary.new;

d.add(\monkey -> 0).postln;

d.add(\robot -> 1).postln;    // Add robot as a key with a value of 1

d.add(\monkey -> 2).postln;    // Replaces the value for the key monkey with 2

)

Associate two objects and add them to the Dictionary.d = Dictionary.new; d.put("abc", 10); // using an event: d = (); d.put("abc", 10);

d = Dictionary.new;

d.put("abc", 10);

​

// using an event:

d = ();

d.put("abc", 10);

Arguments:

Remove the key and the value associated with it from the Dictionary.d = Dictionary[\monkey -> 99]; d.removeAt(\monkey);

xxxxxxxxxx

d = Dictionary[\monkey -> 99];

d.removeAt(\monkey);

Add all items of each argument to the dictionary.d = Dictionary.new; d.putAll(Dictionary[\hello -> 9, \whello -> "world"], Dictionary["abd" -> 6]);

xxxxxxxxxx

d = Dictionary.new;

d.putAll(Dictionary[\hello -> 9, \whello -> "world"], Dictionary["abd" -> 6]);

Arguments:

Add all items to the dictionary, using them as key and value pairwise.d = Dictionary.new; d.putPairs([\hello, 10, \whello, "lord", "abc", 7]);

xxxxxxxxxx

d = Dictionary.new;

d.putPairs([\hello, 10, \whello, "lord", "abc", 7]);

Access the value associated with the key.d = Dictionary[\robot -> 99]; d.at(\robot); // Get the value associated with key d[\robot]; // different syntax, same behaviour d.at(\monkey); // Key doesn't exist: return Nil

xxxxxxxxxx

d = Dictionary[\robot -> 99];

d.at(\robot);    // Get the value associated with key

d[\robot];    // different syntax, same behaviour

d.at(\monkey);    // Key doesn't exist: return Nil

Access the value associated with the key. If the key does not exist, return the result of function.

Return a Set of all keys.d = Dictionary.newFrom([\hello, 9, \whello, "world"]); d.keys;

xxxxxxxxxx

d = Dictionary.newFrom([\hello, 9, \whello, "world"]);

d.keys;

Return a List of all values.d = Dictionary.newFrom([\hello, 9, \whello, "world"]); d.values;

xxxxxxxxxx

d = Dictionary.newFrom([\hello, 9, \whello, "world"]);

d.values;

Return an Array of all values for the given keys.d = Dictionary.newFrom([\hello, 9, \whello, "world", \z, 99, \c, 0.33]); d.atAll([\hello, \z, \hello, \c, \whello]);

xxxxxxxxxx

d = Dictionary.newFrom([\hello, 9, \whello, "world", \z, 99, \c, 0.33]);

d.atAll([\hello, \z, \hello, \c, \whello]);

Return an Array with all keys and values pairwise.

Discussion:

xxxxxxxxxx

d = Dictionary.newFrom([\hello, 9, \whello, 77, \z, 99]);

d.getPairs;

Note that, unlike -asPairs, getPairs will return nil with an empty Dictionary.d = Dictionary.new; d.getPairs;

xxxxxxxxxx

d = Dictionary.new;

d.getPairs;

Access the Association that has the given key. Element is checked for equality (not identity).d = Dictionary["robot" -> 99]; d.associationAt("robot"); // Get the value associated with key

xxxxxxxxxx

d = Dictionary["robot" -> 99];

d.associationAt("robot");    // Get the value associated with key

Try to find a given value and return its key. Element is checked for equality (not identity).d = Dictionary.newFrom([\hello, 1, \whello, 77]); d.findKeyForValue(1);

xxxxxxxxxx

d = Dictionary.newFrom([\hello, 1, \whello, 77]);

d.findKeyForValue(1);

The dictionary's keys are used as conditions against which the arbitrary item is matched. See: matchItemReturns the associated value or nil if no key is matching the item.

• If the key is an object, the item will be matched by identity (if key === item, the value will be returned).
• If the key is a collection, the item is matched if it's contained in the collection.
• If the key is a function, the function is evaluated with the item as an argument and the item is matched if the function returns true.

( d = Dictionary.newFrom([ 0, \zero, \abc, \alpha, [1, 2, 3, 5, 8, 13, 21], \fibonacci, { |x| try { x.even } }, \even // try is needed because argument might not be a number ]); ); d.matchAt(0) // matches both 'zero' and 'even', either may be returned d.matchAt(1) d.matchAt(2) // matches both 'fibonacci' and 'even', either may be returned d.matchAt(4) d.matchAt(\abc)

xxxxxxxxxx

(

d = Dictionary.newFrom([

    0, \zero,

    \abc, \alpha,

    [1, 2, 3, 5, 8, 13, 21], \fibonacci,

    { |x| try { x.even } }, \even // try is needed because argument might not be a number

    ]);

);

​

d.matchAt(0)    // matches both 'zero' and 'even', either may be returned

d.matchAt(1)

d.matchAt(2)    // matches both 'fibonacci' and 'even', either may be returned

d.matchAt(4)

d.matchAt(\abc)

Returns True if the item at the key is true, otherwise false. This method is also valid in Object.

Returns False if the item at the key is not true, otherwise true. This method is inherited from Object.

Returns true if the specified item is stored in the Dictionary as a value. Element is checked for equality (not for identity). For identity matching see subclasses: IdentityDictionary or Event.var d = Dictionary.newFrom([\a, "hey", \b, "hello"]); d.includes("hey").postln; // -> true

xxxxxxxxxx

var d = Dictionary.newFrom([\a, "hey", \b, "hello"]);

d.includes("hey").postln; // -> true

Returns true if the specified item is stored in the Dictionary as a key. Element is checked for equality (not for identity). For identity matching see subclasses: IdentityDictionary or Event.var d = Dictionary.newFrom(["hey", 1, "hello", 2]); d.includesKey("hey").postln; // -> true

xxxxxxxxxx

var d = Dictionary.newFrom(["hey", 1, "hello", 2]);

d.includesKey("hey").postln; // -> true

Iterate over the associations, and evaluate the function for each, passing key and value as argument.d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]]; d.keysValuesDo { |key, value| postln("the key: " ++ key ++ " the value: " ++ value) };

xxxxxxxxxx

d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]];

d.keysValuesDo { |key, value| postln("the key: " ++ key ++ " the value: " ++ value) };

Iterate over the associations, and evaluate the function for each, passing key and value as argument. Replace the value with the return value from the function (similar to -collect, but modifies the dictionary in place).d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]]; d.keysValuesChange { |key, value| "the key: " ++ key ++ " the value: " ++ value }; d;

xxxxxxxxxx

d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]];

d.keysValuesChange { |key, value| "the key: " ++ key ++ " the value: " ++ value };

d;

Iterate over the associations, and evaluate the function for each, passing key as argument.d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]]; d.keysDo { |key| postln("the key: " ++ key) };

xxxxxxxxxx

d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]];

d.keysDo { |key| postln("the key: " ++ key) };

Iterate over the associations, and evaluate the function for each.d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]]; d.associationsDo { |assoc| postln("the association: " ++ assoc) };

xxxxxxxxxx

d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]];

d.associationsDo { |assoc| postln("the association: " ++ assoc) };

Iterate over the associations, and evaluate the function for each, passing key and value as argument. Identical to -keysValuesDo

Return a new dictionary with all the values as keys and vice versa.d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]]; d.invert;

xxxxxxxxxx

d = Dictionary[\a -> "hello", \b -> "robot", \c -> [1, 2, 3]];

d.invert;

Return an array of keys which corresponds to the order of the values of the dictionary.d = Dictionary[\a -> 5, \b -> 7, \c -> 1, \d -> 0]; d.order; d.atAll(d.order); // returns items in order

xxxxxxxxxx

d = Dictionary[\a -> 5, \b -> 7, \c -> 1, \d -> 0];

d.order;

d.atAll(d.order);    // returns items in order

Return the set of all subsets: here an array of all sub-dictionaries.d = Dictionary[\a -> 5, \b -> 7, \c -> 1, \d -> 0]; d.powerset;

xxxxxxxxxx

d = Dictionary[\a -> 5, \b -> 7, \c -> 1, \d -> 0];

d.powerset;

Combine two dictionaries into a new one by applying a function to each value. If fill is true (default: true), values missing from one of them are kept as they are.d = Dictionary[\a -> 5, \b -> 7, \d -> 0]; e = Dictionary[\a -> 3, \b -> -3, \c -> 1]; merge(d, e, { |a, b| a + b }); merge(d, e, { |a, b| a + b }, false);

xxxxxxxxxx

d = Dictionary[\a -> 5, \b -> 7, \d -> 0];

e = Dictionary[\a -> 3, \b -> -3, \c -> 1];

merge(d, e, { |a, b| a + b });

merge(d, e, { |a, b| a + b }, false);

Arguments:

Blend two dictionaries into a new one by interpolating each value. If fill is true (default: true), values missing from one of them are kept as they are.d = Dictionary[\a -> 5, \b -> 7, \d -> 0]; e = Dictionary[\a -> 3, \b -> -3, \c -> 1]; blend(d, e, 0.3); blend(d, e, 0.3, false); d = Dictionary[\a -> 500, \b -> 0.001]; e = Dictionary[\a -> 300, \b -> 0.1]; blend(d, e, 0.3, specs: (a: \freq, b: \rq));

xxxxxxxxxx

d = Dictionary[\a -> 5, \b -> 7, \d -> 0];

e = Dictionary[\a -> 3, \b -> -3, \c -> 1];

blend(d, e, 0.3);

blend(d, e, 0.3, false);

​

d = Dictionary[\a -> 500, \b -> 0.001];

e = Dictionary[\a -> 300, \b -> 0.1];

blend(d, e, 0.3, specs: (a: \freq, b: \rq));

Arguments:

Return the values in a sorted array of key value pairs. Sorted by key.d = Dictionary[\a -> 5, \b -> 7, \c -> 1, \d -> 0]; d.asSortedArray;

xxxxxxxxxx

d = Dictionary[\a -> 5, \b -> 7, \c -> 1, \d -> 0];

d.asSortedArray;

If no arguments are passed, return itself. This is part of the Key Value Pairs interface.

Arguments:

Return the values in an array of alternating key value pairs, like [\freq, 1848, \amp, 0.2]. This is part of the Key Value Pairs interface.

Arguments:

Discussion:

xxxxxxxxxx

d = Dictionary[\a -> 5, \b -> 7, \c -> 1, \d -> 0];

d.asPairs;

Note that, unlike -getPairs, asPairs will return an empty Array with an empty Dictionary.d = Dictionary.new; d.asPairs;

xxxxxxxxxx

d = Dictionary.new;

d.asPairs;

See -asPairs.

Arguments:

xxxxxxxxxx

a = (note: 2);

b = (note: [3, 5]);

Pseq([a, b]).play;

xxxxxxxxxx

(

a = (

    pattern: Pbind(\note, Pgeom(1, 1.1, { 20.rand }), \dur, 0.05),

    embedInStream: { |event, inevent| event[\pattern].embedInStream(inevent) }

);

b = (note: [3, 5]);

c = (freq: 402, dur: 0.3);

Prand([a, b, c], inf).trace.play;

)

​

// change the events while playing

c[\freq] = [900, 1002, 1102];

c[\freq] = [200, 101, 1102];

xxxxxxxxxx

(

d = (

    a: 5, b: 7, c: 1,

    rout: Routine { |inval|

        inf.do { |i|

            var event = d.copy.put(\count, i);

            inval = event.embedInStream(inval);

        }

    }

);

)

​

// draw new values

d.rout.((z:999));

d.rout.((z:1, a:0));

d.rout.(());