What is the purpose of mapping an object to another mapping?

Question

I have seen examples like the following code many times:

mapping (bytes32 => mapping (bytes32 => bytes32[])) items;

And I have tried to recreate something similar here:

mapping(address => uint) public addresskey1;

mapping(uint => mapping(address => uint)) public addresskey2;

function addAddress(address _address, uint _pin) public {

    addresskey1[_address] = ID;

    addresskey2[_pin] = addresskey1[_address];


}

Aside from remix telling me that mappings can't be assigned to, I can't quite figure out what this does. I know that a mapping creates a hash of the keytype which points to a location where the value is stored, but how does it work when

a hash of a key points to another hash of another key which points to the value? My first thought is that the hash immediately tells the computer where to go, and so mapping like this would just create two jumps to the desired value.

In other words, it is a way of creating multiple keys for the same value without having to save the value in multiple locations - but then, the hash of the first mapping must be stored separately anyway, so it wouldn't really save space.

I keep trying to play around with this, but I cannot figure out what it does.

Answer 1

It's like a two-dimensional array.

A common example is in pretty much every ERC20 token. In an ERC20 token, you have the ability to approve other people to spend your tokens. In a single-user case, you might have a mapping like this:

mapping(address => uint256) public allowance;

To look up how much Bob is allowed to spend, you would check allowance[Bob].

In the multi-user case, each user has their own mapping:

mapping(address => mapping(address => uint256)) public allowance;

To look up how much Alice has allowed Bob to spend, you check allowance[Alice][Bob].

Answer 2

This can be explained with an analogy. Mappings can be understood as file organizers. For instance, mapping(address => uint) can be seen as Folder => data, so the address gives the name of the folder and the mapping goes to the folder and retrieve the data.

In a mapping of mappings like mapping(address => mapping(address => uint)) the equivalent analogy is that you are looking in a folder that has a subfolder and inside of the subfolder there is data.

Note that the name of the folders can be given by several types of variables, for instance, in mapping(uint => mapping(uint => uint)) the name of the folder is given by an integer number and the data is another integer number, in mapping(address => mapping(uint => bytes32)) the name of the main folder is given by an address, the subfolder name is given by an integer and the data is a bytes32 variable type.

I hope this helps.