#0"
+}
+```
+
+and so on, until it eventually returns the empty sequence.
+
+ ## Writing a custom matcher
+
+We've learned that the regex syntax is just a function generator, and the signature and return structure of the generated 'matcher' function is well defined. The four regex-aware functions (`$match`, `$contain`, `$split`, `$replace`) simply invoke this function as part of their implementation. Apart from that, they have no awareness that these matcher functions were generated by the regex syntax.
+
+So it's possible to write any user-defined matcher function, provided it conforms to this contract. This can be done as a JSONata lambda function or (more likely) as an extension function. It can then be passed to these four 'regex-aware' functions and they will search using the custom matcher rather than a regex.
diff --git a/website/versioned_docs/version-2.1.0/sorting-grouping.md b/website/versioned_docs/version-2.1.0/sorting-grouping.md
new file mode 100644
index 00000000..2ebbca3f
--- /dev/null
+++ b/website/versioned_docs/version-2.1.0/sorting-grouping.md
@@ -0,0 +1,109 @@
+---
+id: version-2.1.0-sorting-grouping
+title: Sorting, Grouping and Aggregation
+sidebar_label: Sorting, Grouping and Aggregation
+original_id: sorting-grouping
+---
+
+## Sorting
+
+Arrays contain an ordered collection of values. If you need to re-order the values, then the array must be sorted. In JSONata, there are two ways of sorting an array:
+
+1. Using the [`$sort()`](array-functions#sort) function.
+
+2. Using the [order-by](path-operators#order-by-) operator.
+
+The [order-by](path-operators#order-by-) operator is a convenient syntax that can be used directly in a path expression to sort the result sequences in ascending or descending order. The [`$sort()`](array-functions#sort) function requires more syntax to be written, but is more flexible and supports custom comparator functions.
+
+## Grouping
+
+The JSONata [object constructor](construction#object-constructors) syntax allows you to specify an expression for the key in any key/value pair (the value can obviously be an expression too). The key expression must evaluate to a string since this is a restriction on JSON objects. The key and value expressions are evaluated for each item in the input context (see [processing model](processing#the-jsonata-processing-model)). The result of each key/value expression pair is inserted into the resulting JSON object.
+
+If the evaluation of any key expression results in a key that is already in the result object, then the result of its associated value expression will be grouped with the value(s) already associated with that key. Note that the value expressions are not evaluated until all of the grouping has been performed. This allows for aggregation expressions to be evaluated over the collection of items for each group.
+
+__Examples__
+
+- Group all of the product sales by name, with the price of each item in each group
+
+
Account.Order.Product{`Product Name`: Price}
+
{
+ "Bowler Hat": [ 34.45, 34.45 ],
+ "Trilby hat": 21.67,
+ "Cloak": 107.99
+}
+
+
Account.Order.Product {
+ `Product Name`: {"Price": Price, "Qty": Quantity}
+}
+
{
+ "Bowler Hat": {
+ "Price": [ 34.45, 34.45 ],
+ "Qty": [ 2, 4 ]
+ },
+ "Trilby hat": { "Price": 21.67, "Qty": 1 },
+ "Cloak": { "Price": 107.99, "Qty": 1 }
+}
+
+
Account.Order.Product {
+ `Product Name`: $.{"Price": Price, "Qty": Quantity}
+}
+
{
+ "Bowler Hat": [
+ { "Price": 34.45, "Qty": 2 },
+ { "Price": 34.45, "Qty": 4 }
+ ],
+ "Trilby hat": { "Price": 21.67, "Qty": 1 },
+ "Cloak": { "Price": 107.99, "Qty": 1 }
+}
+
+
Account.Order.Product{`Product Name`: $.(Price*Quantity)}
+
{
+ "Bowler Hat": [ 68.9, 137.8 ],
+ "Trilby hat": 21.67,
+ "Cloak": 107.99
+}
+
+
Account.Order.Product{`Product Name`: $sum($.(Price*Quantity))}
+
{
+ "Bowler Hat": 206.7,
+ "Trilby hat": 21.67,
+ "Cloak": 107.99
+}
+
+
$sum(Account.Order.Product.Price)
+
198.56
+
+
$sum(Account.Order.Product.(Price*Quantity))
+
336.36
+