How do I delete entries from mappings with user defined types

Question

user defined value types allow creating a zero cost abstraction over an elementary value type. This is similar to an alias, but with stricter type requirements.

unfortunately, solc 0.8.9 says

TypeError: Unary operator delete cannot be applied to type MyType

type TokenId is uint256;
...
mapping(bytes32 => MyType) public myMapping;
...
delete myMapping[myId];

Is there a way to keep delete for readability, use the type definition, and avoid multiple additional wrap and unwrap ?

Answer 1

I think we can not delete an entry of mapping when using User Defined Value Types. The reason here is no initial default value of user-defined types.

As explained in solidity docs here and here

A user defined value type is defined using type C is V, where C is the name of the newly introduced type and V has to be a built-in value type (the “underlying type”).

The type C does not have any operators or bound member functions. In particular, even the operator == is not defined. Explicit and implicit conversions to and from other types are disallowed.

What delete a does is it assigns the initial value for the type to a. It is important to note that delete a really behaves like an assignment to a, i.e. it stores a new object in a.

I think since user-defined types have no operators or bound members functions assigning an initial of user defined (inherited from the underlying type) type is not possible.

Answer 2

No. You can't delete a mapping entry. You can write over it or set it back to false but you can't delete.

Answer 3

I'm not sure if it's an appropriated way but that's how i create and destroy a new mapping :

contract Mapping {

    mapping (uint256 => uint256) public map;
    // workaround because i can't find a way to directly access to the map on contract MyContract
    function write(uint256 index, uint256 data) public {
        map[index] = data;
    }
}

contract MyContract {
    
    Mapping big_array = new Mapping();
    
    function write(uint256 index, uint256 data) public {
        big_array.write(index,data);
    }
    
    function read(uint256 index) public returns (uint256) {
        return big_array.map(index); // it works, i would like something like that instead of Mapping.write
    }
    
    function newMap() public {
        delete big_array;
        big_array = new Mapping();    
    }
    
}

but ofc it's only useful if you want to delete the whole entries not one in particular.