Did you know ... Search Documentation:
Predicate sort/4
Availability:built-in
sort(+Key, +Order, +List, -Sorted)
True when Sorted can be unified with a list holding the element of List. Key determines which part of each element in List is used for comparing two term and Order describes the relation between each set of consecutive elements in Sorted.142The definition of this predicate was established after discussion with Joachim Schimpf from the ECLiPSe team. ECLiPSe currently only accepts <, =<, > and >= for the Order argument but this is likely to change. SWI-Prolog extends this predicate to deal with dicts.

If Key is the integer zero (0), the entire term is used to compare two elements. Using Key=0 can be used to sort arbitrary Prolog terms. Other values for Key can only be used with compound terms or dicts (see section 5.4). An integer key extracts the Key-th argument from a compound term. An integer or atom key extracts the value from a dict that is associated with the given key. A type_error is raised if the list element is of the wrong type and an existence_error is raised if the compound has not enough argument or the dict does not contain the requested key.

Deeper nested elements of structures can be selected by using a list of keys for the Key argument.

The Order argument is described in the table below:143For compatibility with ECLiPSe, the values <, =<, > and >= are allowed as synonyms.

OrderOrderingDuplicate handling
@< ascendingremove
@=< ascendingkeep
@> descendingremove
@>= descendingkeep

The sort is stable, which implies that, if duplicates are kept, the order of duplicates is not changed. If duplicates are removed, only the first element of a sequence of duplicates appears in Sorted.

This predicate supersedes most of the other sorting primitives, for example: 

sort(List, Sorted)     :- sort(0,  @<, List,  Sorted).
msort(List, Sorted)    :- sort(0, @=<, List,  Sorted).
keysort(Pairs, Sorted) :- sort(1, @=<, Pairs, Sorted).

The following example sorts a list of rows, for example resulting from csv_read_file/2) ascending on the 3rd column and descending on the 4th column (for sets of rows where the 3rd column is equal): 

    sort(4, @>=, Rows0, Rows1),
    sort(3, @=<, Rows1, Sorted).

See also sort/2 (ISO), msort/2, keysort/2, predsort/3 and order_by/2.

Tags are associated to your profile if you are logged in|Report abuse
Tags:
  • doc-needs-help
Carlos Lang-Sanou said (2026-05-15T04:27:31):0 upvotes 0 0 downvotes
Picture of user Carlos Lang-Sanou.

sort/4 in SWI-Prolog

Signature: sort(+Key, +Order, +List, -Sorted)

sort/4 is a generalized sorting predicate that lets you control two things the basic sort/2 doesn't: what part of each element to sort by (the key) and how to order and handle duplicates.

The Arguments

Key — which part of each element to compare. Common values:

  • 0 — use the entire term as the key
  • 1, 2, 3, … — use the Nth argument of a compound term (like f(A,B,C), where 1 picks A)
  • A list of keys (e.g. [2,1]) — for deeper nested access Order — a combination of sort direction and duplicate handling:
    OrderDirectionDuplicates
    @<ascendingremove
    @=<ascendingkeep
    @>descendingremove
    @>=descendingkeep

    List — the input list.

    Sorted — the resulting sorted list (output).

Simple Example

Say you have a list of person(Name, Age) terms and want to sort by age (the 2nd argument) in ascending order, removing duplicates:

?- sort(2, @<, [person(alice, 30), person(bob, 25), person(carol, 30)], Sorted).
Sorted = [person(bob, 25), person(alice, 30)].
  • Key 2 means "compare on the 2nd argument" (the age).
  • @< means ascending, with duplicate keys removed — so alice and carol both have age 30, and only the first one (alice) is kept. If you want to keep both people with age 30, use @=<: 
    ?- sort(2, @=<, [person(alice, 30), person(bob, 25), person(carol, 30)], Sorted).
Sorted = [person(bob, 25), person(alice, 30), person(carol, 30)].

Relation to simpler predicates

sort/4 is a superset of the other sorting predicates. For instance:

  • sort(List, Sorted) is equivalent to sort(0, @<, List, Sorted)
  • msort(List, Sorted) is equivalent to sort(0, @=<, List, Sorted) The sort is stable, meaning that among elements with equal keys, their original relative order is preserved when using a "keep" order (@=< or @>=).

Credits

Produced by Claude.

lasha abzianidze said (2022-01-12T00:38:42):0 upvotes 0 0 downvotes
Picture of user lasha abzianidze.

This behaviour is not entirely obvious. It should be given as an example.

?- sort(1, @>, [1-2, 2-1, 2-2], X).

X = [2-1, 1-2].

Meltem Suiçmez said (2019-04-20T14:27:41):0 upvotes 0 0 downvotes
Picture of user Meltem Suiçmez.
sort(4, @>=, Rows0, Rows1), this should be explained with more example. I don't understand the role of the key value. And what kind of list is Rows0.