# Sort modifier

Learn how to to sort the items of a collection.

This modifier sorts the elements of a [collection](/reference/cql/data-types/core/collection) based on a specified order and mode.

When sorting, this modifier uses the same [comparison rules](/reference/cql/expressions/operations/comparison/overview#comparability) as the relational operators to ensure consistency in how it determines the order of two items. And, as with comparisons, attempting to sort a collection that contains elements that are not comparable will result in an error.

You can also use this modifier to sort [maps](/reference/cql/data-types/core/collection). Although the keys are not used for sorting, they are preserved in the resulting map.

## Syntax

The basic syntax for this modifier is as follows:

```cql
/*<collection>*/ sorted
```

You can optionally specify an order and/or mode for sorting:

```cql
/*<collection>*/ sorted /*<order>*/ /*<mode>*/
```

Note that both `/*<order>*/` and `/*<mode>*/` are literal words and cannot be specified dynamically using expressions.

The following table describes the supported orders:

| Order        | Description                                                                                               |
| ------------ | --------------------------------------------------------------------------------------------------------- |
| `ascending`  | Sort the elements in ascending order (e.g., from the smallest to the largest). This is the default order. |
| `descending` | Sort the elements in descending order (e.g., from the largest to the smallest).                           |

And these are the supported modes and the types they support:

| Mode             | Supported type   | Description                                                                                                                                                                                                                                                                                                                                                                       |
| ---------------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `alphabetical`   | String           | Sort the elements alphabetically.                                                                                                                                                                                                                                                                                                                                                 |
| `alphanumerical` | String           | Sort the elements alphanumerically, also known as [natural sorting](https://en.wikipedia.org/wiki/Natural_sort_order). This mode differs from alphabetical because numbers are sorted numerically rather than [lexicographically](https://en.wikipedia.org/wiki/Lexicographic_order). For example, 10 sorts after 2 in `alphabetical` mode but before 2 in `alphanumerical` mode. |
| `numerical`      | Number or string | Sort the elements numerically. This mode differs from alphanumerical in that it supports comparing numeric strings, integers, decimals, and floats — not just numbers.                                                                                                                                                                                                            |

By default, the modifier uses the `ascending` order and the natural sorting mode, which follows the same [comparison rules](/reference/cql/expressions/operations/comparison/overview#comparability) as the relational operators.

## Parameters

These are the supported parameters:

- `collection`: `collection`

  The collection to sort.

## Examples

Here is a basic example of using this modifier with a list:

```cql
[3, 1, 2] sorted // [1, 2, 3]
```

You can also use this modifier to sort a map:

```cql
["a": 3, "b": 1, "c": 2] sorted // ["b": 1, "c": 2, "a": 3]
```

To sort a collection in a different order, you can specify the direction:

```cql
[1, 3, 2] sorted descending // [3, 2, 1]
```

And to sort a collection in a specific way, you can specify the mode:

```cql
["a", "10", "2"] sorted numerical // ["2", "10", "a"]
```