dictionaryp — Logtalk APIs v3.47.0 documentation

protocol

# `dictionaryp`

Dictionary protocol.

Author: Paulo Moura
Version: 2:3:0
Date: 2021-04-12
Compilation flags:
`static`
Dependencies:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

- Public predicates

  - `as_dictionary/2`

  - `as_list/2`

  - `as_curly_bracketed/2`

  - `clone/3`

  - `clone/4`

  - `insert/4`

  - `delete/4`

  - `update/4`

  - `update/5`

  - `update/3`

  - `empty/1`

  - `lookup/3`

  - `lookup/2`

  - `intersection/2`

  - `intersection/3`

  - `previous/4`

  - `next/4`

  - `min/3`

  - `max/3`

  - `delete_min/4`

  - `delete_max/4`

  - `keys/2`

  - `values/2`

  - `map/2`

  - `map/3`

  - `apply/4`

  - `size/2`

- Protected predicates

- Private predicates

- Operators

## 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.

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 match the old value.

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/3`

Lookups a matching key-value pair from a dictionary.

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.

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.

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.

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.

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)` - `zero_or_one`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)

See also

avltree, bintree, rbtree