object

# pairs

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

author:
  `Paulo Moura`
version:
  `1.4`
date:
  `2017/5/5`

compilation flags:
  `static, context_switching_calls`

(no dependencies on other entities)

## Public interface

### 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 – 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 – 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 – 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 – number of proofs:
  `transpose(+list(pair),-list(pair)) – one`

### group_by_key/2

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

compilation flags:
  `static`
template:
  `group_by_key(Pairs,Groups)`
mode – 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 – number of proofs:
  `map(@callable,+list,-list(pair)) – one`

## Protected interface

(none)

## Private predicates

(none)

## Operators

### (none)

## Remarks

### (none)

## See also

### (none)