Lookup Tables and the Mordant Problem

Phaeolus schweinitzii in a copper pot yields deep green. The same fungus in an iron pot gives rust red. In enamel, orange. The pigment is constant; the metal ions in the vessel wall act as a key that selects which colour complex forms.

Hash tables work the same way: you store values indexed by keys, and retrieval is nearly instant because the key determines where to look. In Perl, they’re called associative arrays, and they’re so fundamental that the language uses % to mark them:

my %vessel_color = (
    'copper' => 'deep green',
    'iron' => 'rust red',
    'enamel' => 'orange',
    'aluminum' => 'pale tan'
);

my $pot = 'iron';
print "Phaeolus in $pot: $vessel_color{$pot}\n";
# Phaeolus in iron: rust red

Swift calls them dictionaries, with type-safe keys and values:

let vesselColor: [String: String] = [
    "copper": "deep green",
    "iron": "rust red",
    "enamel": "orange",
    "aluminum": "pale tan"
]

if let color = vesselColor["copper"] {
    print("Phaeolus in copper: \(color)")
}
// Phaeolus in copper: deep green

The lookup is O(1) average case because the key gets hashed to an array index. Collisions happen when two keys hash to the same bucket—Perl uses chaining (linked lists at each slot), while Swift uses open addressing (probe the next slot). Neither language exposes the hash function, but both guarantee you won’t get rust red when you asked for the copper pot.

In the studio, Diane keeps three dedicated reactive vessels specifically because the vessel history matters—residual metal ions accumulate and affect future batches. Hash tables don’t have that problem. Once you delete a key, it’s gone. The lookup is pure: same key, same value, every time.