protocol

# `dictionaryp`

Dictionary protocol.

Availability:
`logtalk_load(dictionaries(loader))`
Author: Paulo Moura
Version: 2:6:0
Date: 2026-02-10
Compilation flags:
`static`
Dependencies:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

## Public predicates

### `as_dictionary/2`

Converts a list of key-value pairs to a dictionary.

Compilation flags:
`static`
Template:
`as_dictionary(Pairs,Dictionary)`
Mode and number of proofs:
`as_dictionary(@list(pairs),-dictionary)` - `one`

### `as_list/2`

Converts a dictionary to an ordered list (as per standard order) of key-value pairs.

Compilation flags:
`static`
Template:
`as_list(Dictionary,Pairs)`
Mode and number of proofs:
`as_list(@dictionary,-list(pairs))` - `one`

### `as_curly_bracketed/2`

Creates a curly-bracketed term representation of a dictionary.

Compilation flags:
`static`
Template:
`as_curly_bracketed(Dictionary,Term)`
Mode and number of proofs:
`as_curly_bracketed(+dictionary,--term)` - `one`

### `clone/3`

Clones a dictionary using the same keys but with all values unbound and returning a list of all the pairs in the new clone.

Compilation flags:
`static`
Template:
`clone(Dictionary,Clone,ClonePairs)`
Mode and number of proofs:
`clone(+dictionary,-dictionary,-list(pairs))` - `one`

### `clone/4`

Clones a dictionary using the same keys but with all values unbound and returning the list of all pairs in the dictionary and in the clone.

Compilation flags:
`static`
Template:
`clone(Dictionary,Pairs,Clone,ClonePairs)`
Mode and number of proofs:
`clone(+dictionary,-list(pairs),-dictionary,-list(pairs))` - `one`

### `insert/4`

Inserts a key-value pair into a dictionary, returning the updated dictionary. When the key already exists, the associated value is updated.

Compilation flags:
`static`
Template:
`insert(OldDictionary,Key,Value,NewDictionary)`
Mode and number of proofs:
`insert(+dictionary,+ground,@term,-dictionary)` - `one`

### `delete/4`

Deletes a matching key-value pair from a dictionary, returning the updated dictionary. Fails if it cannot find the key or if the key exists but the value does not unify.

Compilation flags:
`static`
Template:
`delete(OldDictionary,Key,Value,NewDictionary)`
Mode and number of proofs:
`delete(+dictionary,@ground,?term,-dictionary)` - `zero_or_one`

### `update/4`

Updates the value associated with Key in a dictionary, returning the updated dictionary. Fails if it cannot find the key.

Compilation flags:
`static`
Template:
`update(OldDictionary,Key,NewValue,NewDictionary)`
Mode and number of proofs:
`update(+dictionary,@ground,+term,-dictionary)` - `zero_or_one`

### `update/5`

Updates the value associated with a key in a dictionary, returning the updated dictionary. Fails if it cannot find the key or if the existing value does not unify.

Compilation flags:
`static`
Template:
`update(OldDictionary,Key,OldValue,NewValue,NewDictionary)`
Mode and number of proofs:
`update(+dictionary,@ground,?term,+term,-dictionary)` - `zero_or_one`

### `update/3`

Updates the key-value pairs in a dictionary, returning the updated dictionary. Fails if it cannot find one of the keys.

Compilation flags:
`static`
Template:
`update(OldDictionary,Pairs,NewDictionary)`
Mode and number of proofs:
`update(+dictionary,@list(pair),-dictionary)` - `zero_or_one`

### `empty/1`

True iff the dictionary is empty.

Compilation flags:
`static`
Template:
`empty(Dictionary)`
Mode and number of proofs:
`empty(@dictionary)` - `zero_or_one`

### `lookup/4`

Lookups a matching key-value pair from a dictionary and returns the splayed dictionary with the key at the root. Fails if the key is not found. In implementations that do not update the dictionary on lookup, the same dictionary is returned.

Compilation flags:
`static`
Template:
`lookup(Key,Value,Dictionary,SplayedDictionary)`
Mode and number of proofs:
`lookup(+ground,?term,+tree,-tree)` - `zero_or_one`

### `lookup/3`

Lookups a matching key-value pair from a dictionary. Fails if no match is found.

Compilation flags:
`static`
Template:
`lookup(Key,Value,Dictionary)`
Mode and number of proofs:
`lookup(+ground,?term,@dictionary)` - `zero_or_one`
`lookup(-ground,?term,@dictionary)` - `zero_or_more`

### `lookup/2`

Lookups all matching key-value pairs from a dictionary. Fails if it cannot find one of the keys or if a value for a key does not unify.

Compilation flags:
`static`
Template:
`lookup(Pairs,Dictionary)`
Mode and number of proofs:
`lookup(+list(pair),@dictionary)` - `zero_or_one`

### `intersection/2`

True iff the values of the dictionaries common keys unify. Trivially true when there are no common keys.

Compilation flags:
`static`
Template:
`intersection(Dictionary1,Dictionary2)`
Mode and number of proofs:
`intersection(+dictionary,+dictionary)` - `zero_or_one`

### `intersection/3`

Returns the (possibly empty) intersection between two dictionaries when the values of their common keys unify.

Compilation flags:
`static`
Template:
`intersection(Dictionary1,Dictionary2,Intersection)`
Mode and number of proofs:
`intersection(+dictionary,+dictionary,-dictionary)` - `zero_or_one`

### `previous/4`

Returns the previous pair in a dictionary given a key. Fails if there is no previous pair.

Compilation flags:
`static`
Template:
`previous(Dictionary,Key,Previous,Value)`
Mode and number of proofs:
`previous(+dictionary,+key,-key,-value)` - `zero_or_one`

### `next/4`

Returns the next pair in a dictionary given a key. Fails if there is no next pair.

Compilation flags:
`static`
Template:
`next(Dictionary,Key,Next,Value)`
Mode and number of proofs:
`next(+dictionary,+key,-key,-value)` - `zero_or_one`

### `min/3`

Returns the pair with the minimum key (as per standard order) in a dictionary. Fails if the dictionary is empty.

Compilation flags:
`static`
Template:
`min(Dictionary,Key,Value)`
Mode and number of proofs:
`min(+dictionary,-key,-value)` - `zero_or_one`

### `max/3`

Returns the pair with the maximum key (as per standard order) in a dictionary. Fails if the dictionary is empty.

Compilation flags:
`static`
Template:
`max(Dictionary,Key,Value)`
Mode and number of proofs:
`max(+dictionary,-key,-value)` - `zero_or_one`

### `delete_min/4`

Deletes the pair with the minimum key (as per standard order) from a dictionary, returning the deleted pair and the updated dictionary. Fails if the dictionary is empty.

Compilation flags:
`static`
Template:
`delete_min(OldDictionary,Key,Value,NewDictionary)`
Mode and number of proofs:
`delete_min(+dictionary,-key,-value,-dictionary)` - `zero_or_one`

### `delete_max/4`

Deletes the pair with the maximum key (as per standard order) from a dictionary, returning the deleted pair and the updated dictionary. Fails if the dictionary is empty.

Compilation flags:
`static`
Template:
`delete_max(OldDictionary,Key,Value,NewDictionary)`
Mode and number of proofs:
`delete_max(+dictionary,-key,-value,-dictionary)` - `zero_or_one`

### `keys/2`

Returns a list with all the dictionary keys in ascending order (as per standard order).

Compilation flags:
`static`
Template:
`keys(Dictionary,Keys)`
Mode and number of proofs:
`keys(@dictionary,-list)` - `one`

### `values/2`

Returns a list with all the dictionary values in ascending order of the keys (as per standard order).

Compilation flags:
`static`
Template:
`values(Dictionary,Values)`
Mode and number of proofs:
`values(@dictionary,-list)` - `one`

### `map/2`

Maps a closure over each dictionary key-value pair. Fails if the mapped closure attempts to modify the keys.

Compilation flags:
`static`
Template:
`map(Closure,Dictionary)`
Meta-predicate template:
`map(1,*)`
Mode and number of proofs:
`map(@callable,+dictionary)` - `zero_or_more`

### `map/3`

Maps a closure over each dictionary key-value pair, returning the new dictionary. Fails if the mapped closure attempts to modify the keys.

Compilation flags:
`static`
Template:
`map(Closure,OldDictionary,NewDictionary)`
Meta-predicate template:
`map(2,*,*)`
Mode and number of proofs:
`map(@callable,+dictionary,-dictionary)` - `zero_or_more`

### `apply/4`

Applies a closure to a specific key-value pair, returning the new dictionary. Fails if the key cannot be found or if the mapped closure attempts to modify the key.

Compilation flags:
`static`
Template:
`apply(Closure,OldDictionary,Key,NewDictionary)`
Meta-predicate template:
`apply(2,*,*,*)`
Mode and number of proofs:
`apply(+callable,+dictionary,+key,-dictionary)` - `zero_or_one`

### `size/2`

Number of dictionary entries.

Compilation flags:
`static`
Template:
`size(Dictionary,Size)`
Mode and number of proofs:
`size(@dictionary,?integer)` - `one`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)

See also

avltree, bintree, rbtree, splaytree