protocol

dictionaryp

Dictionary protocol.

Author: Paulo Moura
Version: 2.1
Date: 2019/5/17
Compilation flags:
static
Dependencies:
(none)
Remarks:
(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 a ordered list of key-value pairs.

Compilation flags:
static
Template:
as_list(Dictionary,Pairs)
Mode and number of proofs:
as_list(@dictionary,-list(pairs)) - 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(+tree,-tree,-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(+tree,-list(pairs),-tree,-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 Key in a dictionary, returning the updated dictionary. Fails if it cannot find the key or if the existing value does not match OldValue.

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

empty/1

True if 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

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

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.

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

Operators

(none)

See also

avltree, bintree, rbtree