Understanding Equality and Identity
[ SHORT VERSION]
Overview
[…]
Core Concepts
Equality (==)
Equality tests whether two objects have equivalent values. In SuperCollider, the == operator compares the contents or values of objects:
// Basic equality examples
"hello" == "hello" // true - same content
[1, 2] == [1, 2] // true - same elements
(a: 1, b: 2) == (a: 1, b: 2) // true - same key/value pairs
// More complex equality
[\a, \b] == ['a', 'b'] // true - symbols compare equally
[1, [2, 3]] == [1, [2, 3]] // true - deep equality comparison
Identity (===)
Identity checks if two variables reference exactly the same object in memory:
// Basic identity examples
a = [1, 2];
b = a; // b references the same array as a
c = [1, 2]; // c is a new array with same content
a === b // true - same object
a === c // false - different objects
a == c // true - but equal content
̶#̶#̶ ̶ ̶-̶-̶-̶M̶a̶t̶h̶e̶m̶a̶t̶i̶c̶a̶l̶ ̶F̶o̶u̶n̶d̶a̶t̶i̶o̶n̶s̶-̶-̶-̶-̶
̶
̶#̶#̶#̶ ̶C̶a̶t̶e̶g̶o̶r̶y̶ ̶T̶h̶e̶o̶r̶y̶ ̶P̶e̶r̶s̶p̶e̶c̶t̶i̶v̶e̶
In category theory, identity has a deeper meaning focused on structure preservation:
̶1̶.̶ ̶̶̶O̶b̶j̶e̶c̶t̶s̶ ̶a̶n̶d̶ ̶M̶o̶r̶p̶h̶i̶s̶m̶s̶̶̶
̶ ̶ ̶ ̶-̶ ̶O̶b̶j̶e̶c̶t̶s̶:̶ ̶A̶b̶s̶t̶r̶a̶c̶t̶ ̶e̶n̶t̶i̶t̶i̶e̶s̶ ̶(̶s̶e̶t̶s̶,̶ ̶t̶y̶p̶e̶s̶,̶ ̶s̶p̶a̶c̶e̶s̶)̶
̶ ̶ ̶ ̶-̶ ̶M̶o̶r̶p̶h̶i̶s̶m̶s̶:̶ ̶S̶t̶r̶u̶c̶t̶u̶r̶e̶-̶p̶r̶e̶s̶e̶r̶v̶i̶n̶g̶ ̶m̶a̶p̶s̶
̶ ̶ ̶ ̶-̶ ̶I̶d̶e̶n̶t̶i̶t̶y̶ ̶m̶o̶r̶p̶h̶i̶s̶m̶:̶ ̶A̶ ̶s̶p̶e̶c̶i̶a̶l̶ ̶t̶r̶a̶n̶s̶f̶o̶r̶m̶a̶t̶i̶o̶n̶ ̶t̶h̶a̶t̶ ̶p̶r̶e̶s̶e̶r̶v̶e̶s̶ ̶s̶t̶r̶u̶c̶t̶u̶r̶e̶
̶
̶2̶.̶ ̶̶̶I̶d̶e̶n̶t̶i̶t̶y̶ ̶F̶u̶n̶c̶t̶i̶o̶n̶̶̶
̶̶̶̶s̶u̶p̶e̶r̶c̶o̶l̶l̶i̶d̶e̶r̶ ̶/̶/̶ ̶M̶a̶t̶h̶e̶m̶a̶t̶i̶c̶a̶l̶ ̶i̶d̶e̶n̶t̶i̶t̶y̶ ̶f̶u̶n̶c̶t̶i̶o̶n̶ ̶f̶ ̶=̶ ̶{̶ ̶|̶x̶|̶ ̶x̶ ̶}̶;̶ ̶ ̶/̶/̶ ̶f̶(̶x̶)̶ ̶=̶ ̶x̶ ̶f̶o̶r̶ ̶a̶l̶l̶ ̶x̶ ̶ ̶/̶/̶ ̶P̶r̶o̶p̶e̶r̶t̶i̶e̶s̶ ̶o̶f̶ ̶i̶d̶e̶n̶t̶i̶t̶y̶ ̶g̶ ̶=̶ ̶{̶ ̶|̶x̶|̶ ̶x̶ ̶+̶ ̶1̶ ̶}̶;̶ ̶x̶ ̶=̶ ̶4̶2̶;̶ ̶ ̶/̶/̶ ̶L̶e̶f̶t̶ ̶a̶n̶d̶ ̶r̶i̶g̶h̶t̶ ̶i̶d̶e̶n̶t̶i̶t̶y̶ ̶f̶.̶(̶g̶.̶(̶x̶)̶)̶ ̶=̶=̶ ̶g̶.̶(̶x̶)̶;̶ ̶ ̶/̶/̶ ̶t̶r̶u̶e̶ ̶-̶ ̶l̶e̶f̶t̶ ̶i̶d̶e̶n̶t̶i̶t̶y̶ ̶g̶.̶(̶f̶.̶(̶x̶)̶)̶ ̶=̶=̶ ̶g̶.̶(̶x̶)̶;̶ ̶ ̶/̶/̶ ̶t̶r̶u̶e̶ ̶-̶ ̶r̶i̶g̶h̶t̶ ̶i̶d̶e̶n̶t̶i̶t̶y̶ ̶̶̶̶
̶
Mathematical vs Programming Identity
The distinction between mathematical and programming identity is crucial:
-
Mathematical Identity
- About value preservation and structure
- Independent of storage or implementation
- Based on abstract properties
-
Programming Identity
- About memory location and object references
- Implementation-dependent
- Practical tool for program logic
Programming Language Perspectives
Haskell’s Approach
Haskell represents a pure functional approach to identity:
-- Identity function composition
main :: IO ()
main = do
print (id (addOne 5)) -- Output: 6
print ((id . addOne) 5) -- Output: 6
print ((addOne . id) 5) -- Output: 6
-- Memory identity using StableName
data Somebody = Somebody { identifier :: String, age :: Int }
main :: IO ()
main = do
let entity1 = Somebody "Zephyr" 30
let entity2 = entity1
let entity3 = Somebody "Zephyr" 30
sn1 <- makeStableName entity1
sn2 <- makeStableName entity2
sn3 <- makeStableName entity3
print (sn1 == sn2) -- True - same memory
print (sn1 == sn3) -- False - different memory
SuperCollider’s Implementation
SuperCollider provides both concepts explicitly:
// Equality for value comparison
Set[1, 2] == Set[2, 1] // true - same elements
Array[1, 2] == Array[1, 2] // true - same structure
// Identity for reference comparison
a = Set[1, 2];
b = a;
a === b // true - same object
Special Cases and Edge Cases
Singletons and Special Objects
// nil - singleton
nil === nil // true
nil == nil // true
// Symbols - unique instances
\hello === \hello // true
'hello' === 'hello' // true
Symbol("hello") === \hello // true
// Numbers
1 == 1.0 // true - equal value
1 === 1.0 // false - different types
Collections and Containers
Different collection types handle equality and identity differently:
// Dictionary vs IdentityDictionary
d = Dictionary.new;
d[1] = "one";
d[1.0]; // "one" - uses equality
i = IdentityDictionary.new;
i[1] = "one";
i[1.0]; // nil - uses identity
// Event behavior
e = (hello: 100);
e[\hello] == e['hello'] // true
e[Symbol("hello")] == e["hello"] // true
Practical Applications
Pattern Matching
Identity is crucial in pattern matching:
// Pattern matching with symbols
p = Pbind(\degree, Pseq([0, 1, 2], inf));
p = Pbind('degree', Pseq([0, 1, 2], inf)); // equivalent
// Event matching
e = (type: \note, degree: 0);
e[\type] === \note // true
Server Integration
// Server objects
s = Server.default;
t = Server.default;
s === t // true - singleton
// Synth nodes
x = Synth(\default);
y = Synth(\default);
x === y // false - different nodes
Best Practices
-
When to Use Equality (==)
- Comparing values or contents
- Testing structural equivalence
- Dictionary key lookup
- Pattern matching
-
When to Use Identity (===)
- Ensuring exact same object
- Performance-critical comparisons
- IdentityDictionary keys
- Singleton checking
-
Performance Considerations
- Identity comparison is faster
- Symbol comparisons are efficient
- Deep equality can be expensive
- Use IdentitySet/IdentityDictionary when appropriate
Common Pitfalls
Floating Point Issues
// Floating point precision
0.1 + 0.1 + 0.1 == 0.3 // might be false!
(0.1 + 0.1 + 0.1 - 0.3).abs < 1e-10 // better approach
Collection Pitfalls
// Nested collection comparison
a = [[1], [2]];
b = [[1], [2]];
a == b // true - deep equality
a === b // false - different objects
a[0] === b[0] // false - nested arrays differ
Implementation Notes
Hash Methods
Objects implement hash methods for lookups:
// Hash for equality
a = "hello";
b = "hello";
a.hash == b.hash // true
a.identityHash == b.identityHash // false
Conclusion
Understanding equality and identity in SuperCollider requires:
- Recognizing the distinction between mathematical and programming concepts
- Understanding implementation details and their implications
- Knowing when to use each comparison type
- Being aware of special cases and potential pitfalls
