Documentation

A map associating keys and values backed by BuiltinData.

This implementation has the following characteristics:

• The toBuiltinData and unsafeFromBuiltinData operations are no-op.
• Other operations are slower than PlutusTx.AssocMap.Map, although equality checks on keys can be faster due to equalsData.
• Many operations involve converting the keys and/or values to/from BuiltinData.

Therefore this implementation is likely a better choice than PlutusTx.AssocMap.Map if it is part of a data type defined using asData, and the key and value types have efficient toBuiltinData and unsafeFromBuiltinData operations (e.g., they are primitive types or types defined using asData).

A Map is considered well-defined if it has no duplicate keys. Most operations preserve the definedness of the resulting Map unless otherwise noted. It is important to observe that, in comparison to standard map implementations, this implementation provides slow lookup and update operations because it is based on a list representation.

Look up the value corresponding to the key. If the Map is not well-defined, the result is the value associated with the left-most occurrence of the key in the list. This operation is O(n).

Check if the key is in the Map.

Insert a key-value pair into the Map. If the key is already present, the value is updated.

Delete a key value pair from the Map. If the Map is not well-defined, it deletes the pair associated with the left-most occurrence of the key in the list.

Create an Map with a single key-value pair.

An empty Map.

Check if the Map is empty.

Convert the Map to a list of key-value pairs. This operation is O(n). See toBuiltinList for a more efficient alternative.

Convert the Map to a BuiltinList of key-value pairs. This operation is O(1).

Create an Map from a sums of products list of key-value pairs. In case of duplicates, this function will keep only one entry (the one that precedes). In other words, this function de-duplicates the input list. Warning: this function is very slow. If you know that the input list does not contain duplicate keys, use one of the unsafe functions instead.

Unsafely create an Map from a sums of products list of pairs. This should _only_ be applied to lists which have been checked to not contain duplicate keys, otherwise the resulting Map will contain conflicting entries (two entries sharing the same key), and therefore be ill-defined. Warning: this requires traversing the list and encoding the keys and values, so it should be avoided in favor of unsafeFromBuiltinList if the input is already in BuiltinData form.

Unsafely create an Map from a List of key-value pairs. This function is unsafe because it assumes that the elements of the list can be safely decoded from their BuiltinData representation. It also does not deduplicate the keys.

Unsafely create an Map from a BuiltinList of key-value pairs. This operation is O(1). This function is unsafe because it assumes that the elements of the list can be safely decoded from their BuiltinData representation. It also does not deduplicate the keys.

Check if the Map is well-defined. Warning: this operation is O(n^2).

Check if any value in the Map satisfies the predicate.

Combine two Maps into one. It saves both values if the key is present in both maps.

Combine two Maps with the given combination function.