object

# `pairs`

Useful predicates over lists of pairs (key-value terms).

Author: Paulo Moura
Version: 2:0:0
Date: 2021-02-22
Compilation flags:
`static, context_switching_calls`
Dependencies:
(none)
Remarks:

> - Usage: This object can be loaded independently of other entities in the `types` library by using the goal `logtalk_load(types(pairs))`.

Inherited public predicates:
(none)

- Public predicates

  - `keys_values/3`

  - `keys/2`

  - `values/2`

  - `transpose/2`

  - `group_sorted_by_key/2`

  - `group_consecutive_by_key/2`

  - `group_by_key/2`

  - `map/3`

- Protected predicates

- Private predicates

- Operators

## Public predicates

### `keys_values/3`

Converts between a list of pairs and lists of keys and values.

Compilation flags:
`static`
Template:
`keys_values(Pairs,Keys,Values)`
Mode and number of proofs:
`keys_values(+list(pair),-list,-list)` - `one`
`keys_values(-list(pair),+list,+list)` - `one`

### `keys/2`

Extracts a list of keys from a list of pairs.

Compilation flags:
`static`
Template:
`keys(Pairs,Keys)`
Mode and number of proofs:
`keys(+list(pair),-list)` - `one`

### `values/2`

Extracts a list of values from a list of pairs.

Compilation flags:
`static`
Template:
`values(Pairs,Values)`
Mode and number of proofs:
`values(+list(pair),-list)` - `one`

### `transpose/2`

Transposes a list of pairs by swapping each pair key and value. The relative order of the list elements is kept.

Compilation flags:
`static`
Template:
`transpose(Pairs,TransposedPairs)`
Mode and number of proofs:
`transpose(+list(pair),-list(pair))` - `one`

### `group_sorted_by_key/2`

Groups pairs by key by sorting them and then constructing new pairs by grouping all values for a given key in a list. Keys are compared using equality. Relative order of values per key is kept. Resulting list of pairs is sorted by key.

Compilation flags:
`static`
Template:
`group_sorted_by_key(Pairs,Groups)`
Mode and number of proofs:
`group_sorted_by_key(+list(pair),-list(pair))` - `one`

### `group_consecutive_by_key/2`

Groups pairs by constructing new pairs by grouping all values for consecutive key in a list. Keys are compared using equality. The relative order of the values for the same key is kept.

Compilation flags:
`static`
Template:
`group_consecutive_by_key(Pairs,Groups)`
Mode and number of proofs:
`group_consecutive_by_key(+list(pair),-list(pair))` - `one`

### `group_by_key/2`

Same as the `group_sorted_by_key/2` predicate. Deprecated.

Compilation flags:
`static`
Template:
`group_by_key(Pairs,Groups)`
Mode and number of proofs:
`group_by_key(+list(pair),-list(pair))` - `one`

### `map/3`

Maps a list into pairs using a closure that applies to each list element to compute its key.

Compilation flags:
`static`
Template:
`map(Closure,List,Pairs)`
Meta-predicate template:
`map(2,*,*)`
Mode and number of proofs:
`map(@callable,+list,-list(pair))` - `one`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)