DOCSUP-924: Higher-order functions moved to Array functions (#14092)

* Higher-order functions description moved to Array functions (English).

* Bad anchor fixed.

* Update docs/en/sql-reference/functions/array-functions.md
Co-authored-by: NIvan Blinkov <github@blinkov.ru>

* Higher-order functions description moved to Array functions (Russian).

* Update array-functions.md

Minor fixes in Russian text.
Co-authored-by: NOlga Revyakina <revolg@yandex.ru>
Co-authored-by: NIvan Blinkov <github@blinkov.ru>

docs/en/operations/system-tables/stack_trace.md

@@ -82,8 +82,8 @@ res:       /lib/x86_64-linux-gnu/libc-2.27.so
 
 -   [Introspection Functions](../../sql-reference/functions/introspection.md) — Which introspection functions are available and how to use them.
 -   [system.trace_log](../system-tables/trace_log.md) — Contains stack traces collected by the sampling query profiler.
--   [arrayMap](../../sql-reference/functions/higher-order-functions.md#higher_order_functions-array-map) — Description and usage example of the `arrayMap` function.
--   [arrayFilter](../../sql-reference/functions/higher-order-functions.md#higher_order_functions-array-filter) — Description and usage example of the `arrayFilter` function.
+-   [arrayMap](../../sql-reference/functions/array-functions.md#array-map) — Description and usage example of the `arrayMap` function.
+-   [arrayFilter](../../sql-reference/functions/array-functions.md#array-filter) — Description and usage example of the `arrayFilter` function.
 
 
 [Original article](https://clickhouse.tech/docs/en/operations/system-tables/stack_trace) <!--hide-->

docs/en/sql-reference/data-types/tuple.md

@@ -7,7 +7,7 @@ toc_title: Tuple(T1, T2, ...)
 
 A tuple of elements, each having an individual [type](../../sql-reference/data-types/index.md#data_types).
 
-Tuples are used for temporary column grouping. Columns can be grouped when an IN expression is used in a query, and for specifying certain formal parameters of lambda functions. For more information, see the sections [IN operators](../../sql-reference/operators/in.md) and [Higher order functions](../../sql-reference/functions/higher-order-functions.md).
+Tuples are used for temporary column grouping. Columns can be grouped when an IN expression is used in a query, and for specifying certain formal parameters of lambda functions. For more information, see the sections [IN operators](../../sql-reference/operators/in.md) and [Higher order functions](../../sql-reference/functions/index.md#higher-order-functions).
 
 Tuples can be the result of a query. In this case, for text formats other than JSON, values are comma-separated in brackets. In JSON formats, tuples are output as arrays (in square brackets).
 

docs/en/sql-reference/functions/arithmetic-functions.md

 ---
-toc_priority: 35
+toc_priority: 34
 toc_title: Arithmetic
 ---
 

docs/en/sql-reference/functions/array-functions.md

 ---
-toc_priority: 46
+toc_priority: 35
 toc_title: Arrays
 ---
 
-# Functions for Working with Arrays {#functions-for-working-with-arrays}
+# Array Functions {#functions-for-working-with-arrays}
 
 ## empty {#function-empty}
 
@@ -241,6 +241,12 @@ SELECT indexOf([1, 3, NULL, NULL], NULL)
 
 Elements set to `NULL` are handled as normal values.
 
+## arrayCount(\[func,\] arr1, …) {#array-count}
+
+Returns the number of elements in the arr array for which func returns something other than 0. If ‘func’ is not specified, it returns the number of non-zero elements in the array.
+
+Note that the `arrayCount` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument. 
+
 ## countEqual(arr, x) {#countequalarr-x}
 
 Returns the number of elements in the array equal to x. Equivalent to arrayCount (elem -\> elem = x, arr).
@@ -568,7 +574,7 @@ SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
 -   `NaN` values are right before `NULL`.
 -   `Inf` values are right before `NaN`.
 
-Note that `arraySort` is a [higher-order function](../../sql-reference/functions/higher-order-functions.md). You can pass a lambda function to it as the first argument. In this case, sorting order is determined by the result of the lambda function applied to the elements of the array.
+Note that `arraySort` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument. In this case, sorting order is determined by the result of the lambda function applied to the elements of the array.
 
 Let’s consider the following example:
 
@@ -668,7 +674,7 @@ SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
 -   `NaN` values are right before `NULL`.
 -   `-Inf` values are right before `NaN`.
 
-Note that the `arrayReverseSort` is a [higher-order function](../../sql-reference/functions/higher-order-functions.md). You can pass a lambda function to it as the first argument. Example is shown below.
+Note that the `arrayReverseSort` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument. Example is shown below.
 
 ``` sql
 SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
@@ -1120,7 +1126,205 @@ Result:
 ``` text
 ┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
 │                                          0.75 │
-└────────────────────────────────────────---──┘
+└───────────────────────────────────────────────┘
+```
+
+## arrayMap(func, arr1, …) {#array-map}
+
+Returns an array obtained from the original application of the `func` function to each element in the `arr` array.
+
+Examples:
+
+``` sql
+SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
+```
+
+``` text
+┌─res─────┐
+│ [3,4,5] │
+└─────────┘
+```
+
+The following example shows how to create a tuple of elements from different arrays:
+
+``` sql
+SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
+```
+
+``` text
+┌─res─────────────────┐
+│ [(1,4),(2,5),(3,6)] │
+└─────────────────────┘
+```
+
+Note that the `arrayMap` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arrayFilter(func, arr1, …) {#array-filter}
+
+Returns an array containing only the elements in `arr1` for which `func` returns something other than 0.
+
+Examples:
+
+``` sql
+SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
+```
+
+``` text
+┌─res───────────┐
+│ ['abc World'] │
+└───────────────┘
+```
+
+``` sql
+SELECT
+    arrayFilter(
+        (i, x) -> x LIKE '%World%',
+        arrayEnumerate(arr),
+        ['Hello', 'abc World'] AS arr)
+    AS res
+```
+
+``` text
+┌─res─┐
+│ [2] │
+└─────┘
+```
+
+Note that the `arrayFilter` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arrayFill(func, arr1, …) {#array-fill}
+
+Scan through `arr1` from the first element to the last element and replace `arr1[i]` by `arr1[i - 1]` if `func` returns 0. The first element of `arr1` will not be replaced.
+
+Examples:
+
+``` sql
+SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
+```
+
+``` text
+┌─res──────────────────────────────┐
+│ [1,1,3,11,12,12,12,5,6,14,14,14] │
+└──────────────────────────────────┘
+```
+
+Note that the `arrayFill` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arrayReverseFill(func, arr1, …) {#array-reverse-fill}
+
+Scan through `arr1` from the last element to the first element and replace `arr1[i]` by `arr1[i + 1]` if `func` returns 0. The last element of `arr1` will not be replaced.
+
+Examples:
+
+``` sql
+SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
+```
+
+``` text
+┌─res────────────────────────────────┐
+│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
+└────────────────────────────────────┘
+```
+
+Note that the `arrayReverseFilter` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arraySplit(func, arr1, …) {#array-split}
+
+Split `arr1` into multiple arrays. When `func` returns something other than 0, the array will be split on the left hand side of the element. The array will not be split before the first element.
+
+Examples:
+
+``` sql
+SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
+```
+
+``` text
+┌─res─────────────┐
+│ [[1,2,3],[4,5]] │
+└─────────────────┘
+```
+
+Note that the `arraySplit` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arrayReverseSplit(func, arr1, …) {#array-reverse-split}
+
+Split `arr1` into multiple arrays. When `func` returns something other than 0, the array will be split on the right hand side of the element. The array will not be split after the last element.
+
+Examples:
+
+``` sql
+SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
+```
+
+``` text
+┌─res───────────────┐
+│ [[1],[2,3,4],[5]] │
+└───────────────────┘
+```
+
+Note that the `arrayReverseSplit` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1}
+
+Returns 1 if there is at least one element in `arr` for which `func` returns something other than 0. Otherwise, it returns 0.
+
+Note that the `arrayExists` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
+
+## arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1}
+
+Returns 1 if `func` returns something other than 0 for all the elements in `arr`. Otherwise, it returns 0.
+
+Note that the `arrayAll` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
+
+## arrayFirst(func, arr1, …) {#array-first}
+
+Returns the first element in the `arr1` array for which `func` returns something other than 0.
+
+Note that the `arrayFirst` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arrayFirstIndex(func, arr1, …) {#array-first-index}
+
+Returns the index of the first element in the `arr1` array for which `func` returns something other than 0.
+
+Note that the `arrayFirstIndex` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You must pass a lambda function to it as the first argument, and it can’t be omitted.
+
+## arraySum(\[func,\] arr1, …) {#array-sum}
+
+Returns the sum of the `func` values. If the function is omitted, it just returns the sum of the array elements.
+
+Note that the `arraySum` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
+
+## arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1}
+
+Returns an array of partial sums of elements in the source array (a running sum). If the `func` function is specified, then the values of the array elements are converted by this function before summing.
+
+Example:
+
+``` sql
+SELECT arrayCumSum([1, 1, 1, 1]) AS res
+```
+
+``` text
+┌─res──────────┐
+│ [1, 2, 3, 4] │
+└──────────────┘
+```
+
+Note that the `arrayCumSum` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
+
+## arrayCumSumNonNegative(arr) {#arraycumsumnonnegativearr}
+
+Same as `arrayCumSum`, returns an array of partial sums of elements in the source array (a running sum). Different `arrayCumSum`, when then returned value contains a value less than zero, the value is replace with zero and the subsequent calculation is performed with zero parameters. For example:
+
+``` sql
+SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
+```
+
+``` text
+┌─res───────┐
+│ [1,2,0,1] │
+└───────────┘
 ```
+Note that the `arraySumNonNegative` is a [higher-order function](../../sql-reference/functions/index.md#higher-order-functions). You can pass a lambda function to it as the first argument.
 
 [Original article](https://clickhouse.tech/docs/en/query_language/functions/array_functions/) <!--hide-->

docs/en/sql-reference/functions/higher-order-functions.md

----
-toc_priority: 57
-toc_title: Higher-Order
----
-
-# Higher-order Functions {#higher-order-functions}
-
-## `->` operator, lambda(params, expr) function {#operator-lambdaparams-expr-function}
-
-Allows describing a lambda function for passing to a higher-order function. The left side of the arrow has a formal parameter, which is any ID, or multiple formal parameters – any IDs in a tuple. The right side of the arrow has an expression that can use these formal parameters, as well as any table columns.
-
-Examples: `x -> 2 * x, str -> str != Referer.`
-
-Higher-order functions can only accept lambda functions as their functional argument.
-
-A lambda function that accepts multiple arguments can be passed to a higher-order function. In this case, the higher-order function is passed several arrays of identical length that these arguments will correspond to.
-
-For some functions, such as [arrayCount](#higher_order_functions-array-count) or [arraySum](#higher_order_functions-array-count), the first argument (the lambda function) can be omitted. In this case, identical mapping is assumed.
-
-A lambda function can’t be omitted for the following functions:
-
--   [arrayMap](#higher_order_functions-array-map)
--   [arrayFilter](#higher_order_functions-array-filter)
--   [arrayFill](#higher_order_functions-array-fill)
--   [arrayReverseFill](#higher_order_functions-array-reverse-fill)
--   [arraySplit](#higher_order_functions-array-split)
--   [arrayReverseSplit](#higher_order_functions-array-reverse-split)
--   [arrayFirst](#higher_order_functions-array-first)
--   [arrayFirstIndex](#higher_order_functions-array-first-index)
-
-### arrayMap(func, arr1, …) {#higher_order_functions-array-map}
-
-Returns an array obtained from the original application of the `func` function to each element in the `arr` array.
-
-Examples:
-
-``` sql
-SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
-```
-
-``` text
-┌─res─────┐
-│ [3,4,5] │
-└─────────┘
-```
-
-The following example shows how to create a tuple of elements from different arrays:
-
-``` sql
-SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
-```
-
-``` text
-┌─res─────────────────┐
-│ [(1,4),(2,5),(3,6)] │
-└─────────────────────┘
-```
-
-Note that the first argument (lambda function) can’t be omitted in the `arrayMap` function.
-
-### arrayFilter(func, arr1, …) {#higher_order_functions-array-filter}
-
-Returns an array containing only the elements in `arr1` for which `func` returns something other than 0.
-
-Examples:
-
-``` sql
-SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
-```
-
-``` text
-┌─res───────────┐
-│ ['abc World'] │
-└───────────────┘
-```
-
-``` sql
-SELECT
-    arrayFilter(
-        (i, x) -> x LIKE '%World%',
-        arrayEnumerate(arr),
-        ['Hello', 'abc World'] AS arr)
-    AS res
-```
-
-``` text
-┌─res─┐
-│ [2] │
-└─────┘
-```
-
-Note that the first argument (lambda function) can’t be omitted in the `arrayFilter` function.
-
-### arrayFill(func, arr1, …) {#higher_order_functions-array-fill}
-
-Scan through `arr1` from the first element to the last element and replace `arr1[i]` by `arr1[i - 1]` if `func` returns 0. The first element of `arr1` will not be replaced.
-
-Examples:
-
-``` sql
-SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
-```
-
-``` text
-┌─res──────────────────────────────┐
-│ [1,1,3,11,12,12,12,5,6,14,14,14] │
-└──────────────────────────────────┘
-```
-
-Note that the first argument (lambda function) can’t be omitted in the `arrayFill` function.
-
-### arrayReverseFill(func, arr1, …) {#higher_order_functions-array-reverse-fill}
-
-Scan through `arr1` from the last element to the first element and replace `arr1[i]` by `arr1[i + 1]` if `func` returns 0. The last element of `arr1` will not be replaced.
-
-Examples:
-
-``` sql
-SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
-```
-
-``` text
-┌─res────────────────────────────────┐
-│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
-└────────────────────────────────────┘
-```
-
-Note that the first argument (lambda function) can’t be omitted in the `arrayReverseFill` function.
-
-### arraySplit(func, arr1, …) {#higher_order_functions-array-split}
-
-Split `arr1` into multiple arrays. When `func` returns something other than 0, the array will be split on the left hand side of the element. The array will not be split before the first element.
-
-Examples:
-
-``` sql
-SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
-```
-
-``` text
-┌─res─────────────┐
-│ [[1,2,3],[4,5]] │
-└─────────────────┘
-```
-
-Note that the first argument (lambda function) can’t be omitted in the `arraySplit` function.
-
-### arrayReverseSplit(func, arr1, …) {#higher_order_functions-array-reverse-split}
-
-Split `arr1` into multiple arrays. When `func` returns something other than 0, the array will be split on the right hand side of the element. The array will not be split after the last element.
-
-Examples:
-
-``` sql
-SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
-```
-
-``` text
-┌─res───────────────┐
-│ [[1],[2,3,4],[5]] │
-└───────────────────┘
-```
-
-Note that the first argument (lambda function) can’t be omitted in the `arraySplit` function.
-
-### arrayCount(\[func,\] arr1, …) {#higher_order_functions-array-count}
-
-Returns the number of elements in the arr array for which func returns something other than 0. If ‘func’ is not specified, it returns the number of non-zero elements in the array.
-
-### arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1}
-
-Returns 1 if there is at least one element in ‘arr’ for which ‘func’ returns something other than 0. Otherwise, it returns 0.
-
-### arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1}
-
-Returns 1 if ‘func’ returns something other than 0 for all the elements in ‘arr’. Otherwise, it returns 0.
-
-### arraySum(\[func,\] arr1, …) {#higher-order-functions-array-sum}
-
-Returns the sum of the ‘func’ values. If the function is omitted, it just returns the sum of the array elements.
-
-### arrayFirst(func, arr1, …) {#higher_order_functions-array-first}
-
-Returns the first element in the ‘arr1’ array for which ‘func’ returns something other than 0.
-
-Note that the first argument (lambda function) can’t be omitted in the `arrayFirst` function.
-
-### arrayFirstIndex(func, arr1, …) {#higher_order_functions-array-first-index}
-
-Returns the index of the first element in the ‘arr1’ array for which ‘func’ returns something other than 0.
-
-Note that the first argument (lambda function) can’t be omitted in the `arrayFirstIndex` function.
-
-### arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1}
-
-Returns an array of partial sums of elements in the source array (a running sum). If the `func` function is specified, then the values of the array elements are converted by this function before summing.
-
-Example:
-
-``` sql
-SELECT arrayCumSum([1, 1, 1, 1]) AS res
-```
-
-``` text
-┌─res──────────┐
-│ [1, 2, 3, 4] │
-└──────────────┘
-```
-
-### arrayCumSumNonNegative(arr) {#arraycumsumnonnegativearr}
-
-Same as `arrayCumSum`, returns an array of partial sums of elements in the source array (a running sum). Different `arrayCumSum`, when then returned value contains a value less than zero, the value is replace with zero and the subsequent calculation is performed with zero parameters. For example:
-
-``` sql
-SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
-```
-
-``` text
-┌─res───────┐
-│ [1,2,0,1] │
-└───────────┘
-```
-
-### arraySort(\[func,\] arr1, …) {#arraysortfunc-arr1}
-
-Returns an array as result of sorting the elements of `arr1` in ascending order. If the `func` function is specified, sorting order is determined by the result of the function `func` applied to the elements of array (arrays)
-
-The [Schwartzian transform](https://en.wikipedia.org/wiki/Schwartzian_transform) is used to improve sorting efficiency.
-
-Example:
-
-``` sql
-SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]);
-```
-
-``` text
-┌─res────────────────┐
-│ ['world', 'hello'] │
-└────────────────────┘
-```
-
-For more information about the `arraySort` method, see the [Functions for Working With Arrays](../../sql-reference/functions/array-functions.md#array_functions-sort) section.
-
-### arrayReverseSort(\[func,\] arr1, …) {#arrayreversesortfunc-arr1}
-
-Returns an array as result of sorting the elements of `arr1` in descending order. If the `func` function is specified, sorting order is determined by the result of the function `func` applied to the elements of array (arrays).
-
-Example:
-
-``` sql
-SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
-```
-
-``` text
-┌─res───────────────┐
-│ ['hello','world'] │
-└───────────────────┘
-```
-
-For more information about the `arrayReverseSort` method, see the [Functions for Working With Arrays](../../sql-reference/functions/array-functions.md#array_functions-reverse-sort) section.
-
-[Original article](https://clickhouse.tech/docs/en/query_language/functions/higher_order_functions/) <!--hide-->

docs/en/sql-reference/functions/index.md

@@ -44,6 +44,21 @@ Functions have the following behaviors:
 
 Functions can’t change the values of their arguments – any changes are returned as the result. Thus, the result of calculating separate functions does not depend on the order in which the functions are written in the query.
 
+## Higher-order functions, `->` operator and lambda(params, expr) function {#higher-order-functions}
+
+Higher-order functions can only accept lambda functions as their functional argument. To pass a lambda function to a higher-order function use `->` operator. The left side of the arrow has a formal parameter, which is any ID, or multiple formal parameters – any IDs in a tuple. The right side of the arrow has an expression that can use these formal parameters, as well as any table columns.
+
+Examples: 
+
+```
+x -> 2 * x
+str -> str != Referer
+```
+
+A lambda function that accepts multiple arguments can also be passed to a higher-order function. In this case, the higher-order function is passed several arrays of identical length that these arguments will correspond to.
+
+For some functions the first argument (the lambda function) can be omitted. In this case, identical mapping is assumed.
+
 ## Error Handling {#error-handling}
 
 Some functions might throw an exception if the data is invalid. In this case, the query is canceled and an error text is returned to the client. For distributed processing, when an exception occurs on one of the servers, the other servers also attempt to abort the query.

docs/en/sql-reference/functions/introspection.md

@@ -98,7 +98,7 @@ LIMIT 1
 \G
 ```
 
-The [arrayMap](../../sql-reference/functions/higher-order-functions.md#higher_order_functions-array-map) function allows to process each individual element of the `trace` array by the `addressToLine` function. The result of this processing you see in the `trace_source_code_lines` column of output.
+The [arrayMap](../../sql-reference/functions/array-functions.md#array-map) function allows to process each individual element of the `trace` array by the `addressToLine` function. The result of this processing you see in the `trace_source_code_lines` column of output.
 
 ``` text
 Row 1:
@@ -184,7 +184,7 @@ LIMIT 1
 \G
 ```
 
-The [arrayMap](../../sql-reference/functions/higher-order-functions.md#higher_order_functions-array-map) function allows to process each individual element of the `trace` array by the `addressToSymbols` function. The result of this processing you see in the `trace_symbols` column of output.
+The [arrayMap](../../sql-reference/functions/array-functions.md#array-map) function allows to process each individual element of the `trace` array by the `addressToSymbols` function. The result of this processing you see in the `trace_symbols` column of output.
 
 ``` text
 Row 1:
@@ -281,7 +281,7 @@ LIMIT 1
 \G
 ```
 
-The [arrayMap](../../sql-reference/functions/higher-order-functions.md#higher_order_functions-array-map) function allows to process each individual element of the `trace` array by the `demangle` function. The result of this processing you see in the `trace_functions` column of output.
+The [arrayMap](../../sql-reference/functions/array-functions.md#array-map) function allows to process each individual element of the `trace` array by the `demangle` function. The result of this processing you see in the `trace_functions` column of output.
 
 ``` text
 Row 1:

docs/ru/operations/system-tables/stack_trace.md

@@ -82,7 +82,7 @@ res:       /lib/x86_64-linux-gnu/libc-2.27.so
 
 -   [Функции интроспекции](../../sql-reference/functions/introspection.md) — Что такое функции интроспекции и как их использовать.
 -   [system.trace_log](../../operations/system-tables/trace_log.md#system_tables-trace_log) — Содержит трассировки стека, собранные профилировщиком выборочных запросов.
--   [arrayMap](../../sql-reference/functions/higher-order-functions.md#higher_order_functions-array-map) — Описание и пример использования функции `arrayMap`.
--   [arrayFilter](../../sql-reference/functions/higher-order-functions.md#higher_order_functions-array-filter) — Описание и пример использования функции `arrayFilter`.
+-   [arrayMap](../../sql-reference/functions/array-functions.md#array-map) — Описание и пример использования функции `arrayMap`.
+-   [arrayFilter](../../sql-reference/functions/array-functions.md#array-filter) — Описание и пример использования функции `arrayFilter`.
 
 [Оригинальная статья](https://clickhouse.tech/docs/ru/operations/system_tables/stack_trace) <!--hide-->

docs/ru/sql-reference/data-types/tuple.md

@@ -2,7 +2,7 @@
 
 Кортеж из элементов любого [типа](index.md#data_types). Элементы кортежа могут быть одного или разных типов.
 
-Кортежи используются для временной группировки столбцов. Столбцы могут группироваться при использовании выражения IN в запросе, а также для указания нескольких формальных параметров лямбда-функций. Подробнее смотрите разделы [Операторы IN](../../sql-reference/data-types/tuple.md), [Функции высшего порядка](../../sql-reference/functions/higher-order-functions.md#higher-order-functions).
+Кортежи используются для временной группировки столбцов. Столбцы могут группироваться при использовании выражения IN в запросе, а также для указания нескольких формальных параметров лямбда-функций. Подробнее смотрите разделы [Операторы IN](../../sql-reference/data-types/tuple.md), [Функции высшего порядка](../../sql-reference/functions/index.md#higher-order-functions).
 
 Кортежи могут быть результатом запроса. В этом случае, в текстовых форматах кроме JSON, значения выводятся в круглых скобках через запятую. В форматах JSON, кортежи выводятся в виде массивов (в квадратных скобках).
 

docs/ru/sql-reference/functions/array-functions.md

-# Функции по работе с массивами {#funktsii-po-rabote-s-massivami}
+# Массивы {#functions-for-working-with-arrays}
 
 ## empty {#function-empty}
 
@@ -186,6 +186,13 @@ SELECT indexOf([1, 3, NULL, NULL], NULL)
 
 Элементы, равные `NULL`, обрабатываются как обычные значения.
 
+## arrayCount(\[func,\] arr1, …) {#array-count}
+
+Возвращает количество элементов массива `arr`, для которых функция `func` возвращает не 0. Если `func` не указана - возвращает количество ненулевых элементов массива.
+
+Функция `arrayCount` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию.
+
+
 ## countEqual(arr, x) {#countequalarr-x}
 
 Возвращает количество элементов массива, равных x. Эквивалентно arrayCount(elem -\> elem = x, arr).
@@ -513,7 +520,7 @@ SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
 -   Значения `NaN` идут перед `NULL`.
 -   Значения `Inf` идут перед `NaN`.
 
-Функция `arraySort` является [функцией высшего порядка](higher-order-functions.md) — в качестве первого аргумента ей можно передать лямбда-функцию. В этом случае порядок сортировки определяется результатом применения лямбда-функции на элементы массива.
+Функция `arraySort` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию. В этом случае порядок сортировки определяется результатом применения лямбда-функции на элементы массива.
 
 Рассмотрим пример:
 
@@ -613,7 +620,7 @@ SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
 -   Значения `NaN` идут перед `NULL`.
 -   Значения `-Inf` идут перед `NaN`.
 
-Функция `arrayReverseSort` является [функцией высшего порядка](higher-order-functions.md). Вы можете передать ей в качестве первого аргумента лямбда-функцию. Например:
+Функция `arrayReverseSort` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей можно передать лямбда-функцию. Например:
 
 ``` sql
 SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
@@ -1036,6 +1043,116 @@ SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1])
 └──────────────────────────────────────┘
 ```
 
+## arrayMap(func, arr1, …) {#array-map}
+
+Возвращает массив, полученный на основе результатов применения функции `func` к каждому элементу массива `arr`.
+
+Примеры:
+
+``` sql
+SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
+```
+
+``` text
+┌─res─────┐
+│ [3,4,5] │
+└─────────┘
+```
+
+Следующий пример показывает, как создать кортежи из элементов разных массивов:
+
+``` sql
+SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
+```
+
+``` text
+┌─res─────────────────┐
+│ [(1,4),(2,5),(3,6)] │
+└─────────────────────┘
+```
+
+Функция `arrayMap` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
+
+## arrayFilter(func, arr1, …) {#array-filter}
+
+Возвращает массив, содержащий только те элементы массива `arr1`, для которых функция `func` возвращает не 0.
+
+Примеры:
+
+``` sql
+SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
+```
+
+``` text
+┌─res───────────┐
+│ ['abc World'] │
+└───────────────┘
+```
+
+``` sql
+SELECT
+    arrayFilter(
+        (i, x) -> x LIKE '%World%',
+        arrayEnumerate(arr),
+        ['Hello', 'abc World'] AS arr)
+    AS res
+```
+
+``` text
+┌─res─┐
+│ [2] │
+└─────┘
+```
+
+Функция `arrayFilter` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
+
+## arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1}
+
+Возвращает 1, если существует хотя бы один элемент массива `arr`, для которого функция func возвращает не 0. Иначе возвращает 0.
+
+Функция `arrayExists` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) - в качестве первого аргумента ей можно передать лямбда-функцию.
+
+## arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1}
+
+Возвращает 1, если для всех элементов массива `arr`, функция `func` возвращает не 0. Иначе возвращает 0.
+
+Функция `arrayAll` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) - в качестве первого аргумента ей можно передать лямбда-функцию.
+
+## arrayFirst(func, arr1, …) {#array-first}
+
+Возвращает первый элемент массива `arr1`, для которого функция func возвращает не 0.
+
+Функция `arrayFirst` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
+
+## arrayFirstIndex(func, arr1, …) {#array-first-index}
+
+Возвращает индекс первого элемента массива `arr1`, для которого функция func возвращает не 0.
+
+Функция `arrayFirstIndex` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) — в качестве первого аргумента ей нужно передать лямбда-функцию, и этот аргумент не может быть опущен.
+
+## arraySum(\[func,\] arr1, …) {#array-sum}
+
+Возвращает сумму значений функции `func`. Если функция не указана - просто возвращает сумму элементов массива.
+
+Функция `arraySum` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) - в качестве первого аргумента ей можно передать лямбда-функцию.
+
+## arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1}
+
+Возвращает массив из частичных сумм элементов исходного массива (сумма с накоплением). Если указана функция `func`, то значения элементов массива преобразуются этой функцией перед суммированием.
+
+Функция `arrayCumSum` является [функцией высшего порядка](../../sql-reference/functions/index.md#higher-order-functions) - в качестве первого аргумента ей можно передать лямбда-функцию.
+
+Пример:
+
+``` sql
+SELECT arrayCumSum([1, 1, 1, 1]) AS res
+```
+
+``` text
+┌─res──────────┐
+│ [1, 2, 3, 4] │
+└──────────────┘
+
 ## arrayAUC {#arrayauc}
 
 Вычисляет площадь под кривой.

docs/ru/sql-reference/functions/higher-order-functions.md

-# Функции высшего порядка {#higher-order-functions}
-
-## Оператор `->`, функция lambda(params, expr) {#operator-funktsiia-lambdaparams-expr}
-
-Позволяет описать лямбда-функцию для передачи в функцию высшего порядка. Слева от стрелочки стоит формальный параметр - произвольный идентификатор, или несколько формальных параметров - произвольные идентификаторы в кортеже. Справа от стрелочки стоит выражение, в котором могут использоваться эти формальные параметры, а также любые столбцы таблицы.
-
-Примеры: `x -> 2 * x, str -> str != Referer.`
-
-Функции высшего порядка, в качестве своего функционального аргумента могут принимать только лямбда-функции.
-
-В функции высшего порядка может быть передана лямбда-функция, принимающая несколько аргументов. В этом случае, в функцию высшего порядка передаётся несколько массивов одинаковых длин, которым эти аргументы будут соответствовать.
-
-Для некоторых функций, например [arrayCount](#higher_order_functions-array-count) или [arraySum](#higher_order_functions-array-sum), первый аргумент (лямбда-функция) может отсутствовать. В этом случае, подразумевается тождественное отображение.
-
-Для функций, перечисленных ниже, лямбда-функцию должна быть указана всегда:
-
--   [arrayMap](#higher_order_functions-array-map)
--   [arrayFilter](#higher_order_functions-array-filter)
--   [arrayFirst](#higher_order_functions-array-first)
--   [arrayFirstIndex](#higher_order_functions-array-first-index)
-
-### arrayMap(func, arr1, …) {#higher_order_functions-array-map}
-
-Вернуть массив, полученный на основе результатов применения функции `func` к каждому элементу массива `arr`.
-
-Примеры:
-
-``` sql
-SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
-```
-
-``` text
-┌─res─────┐
-│ [3,4,5] │
-└─────────┘
-```
-
-Следующий пример показывает, как создать кортежи из элементов разных массивов:
-
-``` sql
-SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
-```
-
-``` text
-┌─res─────────────────┐
-│ [(1,4),(2,5),(3,6)] │
-└─────────────────────┘
-```
-
-Обратите внимание, что у функции `arrayMap` первый аргумент (лямбда-функция) не может быть опущен.
-
-### arrayFilter(func, arr1, …) {#higher_order_functions-array-filter}
-
-Вернуть массив, содержащий только те элементы массива `arr1`, для которых функция `func` возвращает не 0.
-
-Примеры:
-
-``` sql
-SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
-```
-
-``` text
-┌─res───────────┐
-│ ['abc World'] │
-└───────────────┘
-```
-
-``` sql
-SELECT
-    arrayFilter(
-        (i, x) -> x LIKE '%World%',
-        arrayEnumerate(arr),
-        ['Hello', 'abc World'] AS arr)
-    AS res
-```
-
-``` text
-┌─res─┐
-│ [2] │
-└─────┘
-```
-
-Обратите внимание, что у функции `arrayFilter` первый аргумент (лямбда-функция) не может быть опущен.
-
-### arrayCount(\[func,\] arr1, …) {#higher_order_functions-array-count}
-
-Вернуть количество элементов массива `arr`, для которых функция func возвращает не 0. Если func не указана - вернуть количество ненулевых элементов массива.
-
-### arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1}
-
-Вернуть 1, если существует хотя бы один элемент массива `arr`, для которого функция func возвращает не 0. Иначе вернуть 0.
-
-### arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1}
-
-Вернуть 1, если для всех элементов массива `arr`, функция `func` возвращает не 0. Иначе вернуть 0.
-
-### arraySum(\[func,\] arr1, …) {#higher_order_functions-array-sum}
-
-Вернуть сумму значений функции `func`. Если функция не указана - просто вернуть сумму элементов массива.
-
-### arrayFirst(func, arr1, …) {#higher_order_functions-array-first}
-
-Вернуть первый элемент массива `arr1`, для которого функция func возвращает не 0.
-
-Обратите внимание, что у функции `arrayFirst` первый аргумент (лямбда-функция) не может быть опущен.
-
-### arrayFirstIndex(func, arr1, …) {#higher_order_functions-array-first-index}
-
-Вернуть индекс первого элемента массива `arr1`, для которого функция func возвращает не 0.
-
-Обратите внимание, что у функции `arrayFirstFilter` первый аргумент (лямбда-функция) не может быть опущен.
-
-### arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1}
-
-Возвращает массив из частичных сумм элементов исходного массива (сумма с накоплением). Если указана функция `func`, то значения элементов массива преобразуются этой функцией перед суммированием.
-
-Пример:
-
-``` sql
-SELECT arrayCumSum([1, 1, 1, 1]) AS res
-```
-
-``` text
-┌─res──────────┐
-│ [1, 2, 3, 4] │
-└──────────────┘
-```
-
-### arraySort(\[func,\] arr1, …) {#arraysortfunc-arr1}
-
-Возвращает отсортированный в восходящем порядке массив `arr1`. Если задана функция `func`, то порядок сортировки определяется результатом применения функции `func` на элементы массива (массивов).
-
-Для улучшения эффективности сортировки применяется [Преобразование Шварца](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A8%D0%B2%D0%B0%D1%80%D1%86%D0%B0).
-
-Пример:
-
-``` sql
-SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]);
-```
-
-``` text
-┌─res────────────────┐
-│ ['world', 'hello'] │
-└────────────────────┘
-```
-
-Подробная информация о методе `arraySort` приведена в разделе [Функции по работе с массивами](array-functions.md#array_functions-sort).
-
-### arrayReverseSort(\[func,\] arr1, …) {#arrayreversesortfunc-arr1}
-
-Возвращает отсортированный в нисходящем порядке массив `arr1`. Если задана функция `func`, то порядок сортировки определяется результатом применения функции `func` на элементы массива (массивов).
-
-Пример:
-
-``` sql
-SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
-```
-
-``` text
-┌─res───────────────┐
-│ ['hello','world'] │
-└───────────────────┘
-```
-
-Подробная информация о методе `arrayReverseSort` приведена в разделе [Функции по работе с массивами](array-functions.md#array_functions-reverse-sort).
-
-[Оригинальная статья](https://clickhouse.tech/docs/ru/query_language/functions/higher_order_functions/) <!--hide-->

docs/ru/sql-reference/functions/index.md

@@ -38,6 +38,20 @@
 
 Функции не могут поменять значения своих аргументов - любые изменения возвращаются в качестве результата. Соответственно, от порядка записи функций в запросе, результат вычислений отдельных функций не зависит.
 
+## Функции высшего порядка, оператор `->` и функция lambda(params, expr)  {#higher-order-functions}
+
+Функции высшего порядка, в качестве своего функционального аргумента могут принимать только лямбда-функции. Чтобы передать лямбда-функцию в функцию высшего порядка, используйте оператор `->`. Слева от стрелочки стоит формальный параметр — произвольный идентификатор, или несколько формальных параметров — произвольные идентификаторы в кортеже. Справа от стрелочки стоит выражение, в котором могут использоваться эти формальные параметры, а также любые столбцы таблицы.
+
+Примеры: 
+```
+x -> 2 * x 
+str -> str != Referer
+```
+
+В функции высшего порядка может быть передана лямбда-функция, принимающая несколько аргументов. В этом случае в функцию высшего порядка передаётся несколько массивов одинаковой длины, которым эти аргументы будут соответствовать.
+
+Для некоторых функций первый аргумент (лямбда-функция) может отсутствовать. В этом случае подразумевается тождественное отображение.
+
 ## Обработка ошибок {#obrabotka-oshibok}
 
 Некоторые функции могут кидать исключения в случае ошибочных данных. В этом случае, выполнение запроса прерывается, и текст ошибки выводится клиенту. При распределённой обработке запроса, при возникновении исключения на одном из серверов, на другие серверы пытается отправиться просьба тоже прервать выполнение запроса.

docs/ru/sql-reference/functions/introspection.md

@@ -93,7 +93,7 @@ LIMIT 1
 \G
 ```
 
-Функция [arrayMap](higher-order-functions.md#higher_order_functions-array-map) позволяет обрабатывать каждый отдельный элемент массива `trace` с помощью функции `addressToLine`. Результат этой обработки вы видите в виде `trace_source_code_lines` колонки выходных данных.
+Функция [arrayMap](../../sql-reference/functions/array-functions.md#array-map) позволяет обрабатывать каждый отдельный элемент массива `trace` с помощью функции `addressToLine`. Результат этой обработки вы видите в виде `trace_source_code_lines` колонки выходных данных.
 
 ``` text
 Row 1:
@@ -179,7 +179,7 @@ LIMIT 1
 \G
 ```
 
-То [arrayMap](higher-order-functions.md#higher_order_functions-array-map) функция позволяет обрабатывать каждый отдельный элемент системы. `trace` массив по типу `addressToSymbols` функция. Результат этой обработки вы видите в виде `trace_symbols` колонка выходных данных.
+То [arrayMap](../../sql-reference/functions/array-functions.md#array-map) функция позволяет обрабатывать каждый отдельный элемент системы. `trace` массив по типу `addressToSymbols` функция. Результат этой обработки вы видите в виде `trace_symbols` колонка выходных данных.
 
 ``` text
 Row 1:
@@ -276,7 +276,7 @@ LIMIT 1
 \G
 ```
 
-Функция [arrayMap](higher-order-functions.md#higher_order_functions-array-map) позволяет обрабатывать каждый отдельный элемент массива `trace` с помощью функции `demangle`.
+Функция [arrayMap](../../sql-reference/functions/array-functions.md#array-map) позволяет обрабатывать каждый отдельный элемент массива `trace` с помощью функции `demangle`.
 
 ``` text
 Row 1: