Improvements based on other reviews

Author: Blargian

src/Functions/array/arrayCompact.cpp

@@ -162,11 +162,11 @@ using FunctionArrayCompact = FunctionArrayMapped<ArrayCompactImpl, NameArrayComp
 REGISTER_FUNCTION(ArrayCompact)
 {
     FunctionDocumentation::Description description = "Removes consecutive duplicate elements from an array. The order of result values is determined by the order in the source array.";
-    FunctionDocumentation::Syntax syntax = "arrayCompact(x)";
+    FunctionDocumentation::Syntax syntax = "arrayCompact(arr)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "An array to remove duplicates from. [`Array`](/sql-reference/data-types/array)"}
+        {"arr", "An array to remove duplicates from. [`Array(T)`](/sql-reference/data-types/array)"}
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array without duplicate values. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array without duplicate values. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);", "[1,nan,nan,2,3]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayFlatten.cpp

@@ -132,11 +132,11 @@ Converts an array of arrays to a flat array.
 
 The flattened array contains all the elements from all source arrays.
 )";
-    FunctionDocumentation::Syntax syntax = "arrayFlatten(x)";
+    FunctionDocumentation::Syntax syntax = "arrayFlatten(arr)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "A multidimensional array. [`Array`](/sql-reference/data-types/array)(`Array`)"}
+        {"arr", "A multidimensional array. [`Array(T)`](/sql-reference/data-types/array)(`Array`)"}
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns a flattened array from the multidimensional array. [`Array`](/sql-reference/data-types/array).";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns a flattened array from the multidimensional array. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayFlatten([[[1]], [[2], [3]]]);", "[1,2,3]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayFold.cpp

@@ -290,13 +290,13 @@ class FunctionArrayFold : public IFunction
 REGISTER_FUNCTION(ArrayFold)
 {
     FunctionDocumentation::Description description = "Applies a lambda function to one or more equally-sized arrays and collects the result in an accumulator.";
-    FunctionDocumentation::Syntax syntax = "arrayFold(λ(acc, x1 [, x2, x3, ... xN]), x1 [, x2, x3, ... xN], acc)";
+    FunctionDocumentation::Syntax syntax = "arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)";
     FunctionDocumentation::Arguments arguments = {
-        {"λ(acc, x1 [, x2, x3, ... xN])", "A lambda function `λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN])` where `F` is an operation applied to `acc` and the values of one, or multiple arrays, with the result of `acc` re-used. [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)"},
-        {"x1 [, x2, x3, ... xN]", "N arrays over which to operate. [Array](/sql-reference/data-types/array)"},
+        {"λ(x, x1 [, x2, x3, ... xN])", "A lambda function `λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN])` where `F` is an operation applied to `acc` and array values from `x` with the result of `acc` re-used. [Lambda function](/sql-reference/functions/overview#arrow-operator-and-lambda)."},
+        {"arr1 [, arr2, arr3, ... arrN]", "N arrays over which to operate. [`Array(T)`](/sql-reference/data-types/array)"},
         {"acc", "Accumulator value with the same type as the return type of the Lambda function."}
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns the result of the lambda sequentially applied to each";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns the final `acc` value.";
     FunctionDocumentation::Examples examples = {
 {
 "Usage example",

src/Functions/array/arrayJaccardIndex.cpp

@@ -152,12 +152,12 @@ class FunctionArrayJaccardIndex : public IFunction
 REGISTER_FUNCTION(ArrayJaccardIndex)
 {
     FunctionDocumentation::Description description = "Returns the [Jaccard index](https://en.wikipedia.org/wiki/Jaccard_index) of two arrays.";
-    FunctionDocumentation::Syntax syntax = "arrayJaccardIndex(x, y)";
+    FunctionDocumentation::Syntax syntax = "arrayJaccardIndex(arr_x, arr_y)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "First array. [Array](/sql-reference/data-types/array)."},
-        {"y", "Second array. [Array](/sql-reference/data-types/array)."},
+        {"arr_x", "First array. [`Array(T)`](/sql-reference/data-types/array)."},
+        {"arr_y", "Second array. [`Array(T)`](/sql-reference/data-types/array)."},
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns the Jaccard index of `x` and `y`.[Float64](/sql-reference/data-types/float)";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns the Jaccard index of `arr_x` and `arr_y`.[Float64](/sql-reference/data-types/float)";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res", "0.3333333333333333"}};
     FunctionDocumentation::IntroducedIn introduced_in = {23, 7};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayReduce.cpp

@@ -221,10 +221,10 @@ Applies an aggregate function to array elements and returns its result.
 The name of the aggregation function is passed as a string in single quotes `'max'`, `'sum'`.
 When using parametric aggregate functions, the parameter is indicated after the function name in parentheses `'uniqUpTo(6)'`.
 )";
-    FunctionDocumentation::Syntax syntax = "arrayReduce(agg_f, x1, x2, ..., xN)";
+    FunctionDocumentation::Syntax syntax = "arrayReduce(agg_f, arr1 [, arr2, ... , arrN)]";
     FunctionDocumentation::Arguments arguments = {
-        {"agg_f", "The name of an aggregate function which should be a constant [string](/sql-reference/data-types/string)."},
-        {"xN", "Any number of [array](/sql-reference/data-types/array) type columns as the parameters of the aggregation function."},
+        {"agg_f", "The name of an aggregate function which should be a constant [String](/sql-reference/data-types/string)."},
+        {"arr1 [, arr2, ... , arrN)]", "N arrays corresponding to the arguments of `agg_f`. [`Array(T)`](/sql-reference/data-types/array)."},
     };
     FunctionDocumentation::ReturnedValue returned_value = "Returns the result of the aggregate function";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayReduce('max', [1, 2, 3]);", R"(

src/Functions/array/arrayReduceInRanges.cpp

@@ -388,16 +388,16 @@ ColumnPtr FunctionArrayReduceInRanges::executeImpl(
 REGISTER_FUNCTION(ArrayReduceInRanges)
 {
     FunctionDocumentation::Description description = R"(
-Applies an aggregate function to array elements in given ranges and returns an array containing the result corresponding to each range.
+Applies an aggregate function to array elements in the given ranges and returns an array containing the result corresponding to each range.
 The function will return the same result as multiple `arrayReduce(agg_func, arraySlice(arr1, index, length), ...)`.
 )";
-    FunctionDocumentation::Syntax syntax = "arrayReduceInRanges(agg_f, ranges, x1, x2, ..., xN)";
+    FunctionDocumentation::Syntax syntax = "arrayReduceInRanges(agg_f, ranges, arr1 [, arr2, ... ,arrN)]";
     FunctionDocumentation::Arguments arguments = {
         {"agg_f", "The name of the aggregate function to use. [String](/sql-reference/data-types/string)"},
-        {"ranges", "The range over which to aggregate. An array of tuples, `(i, r)` containing the index `i` from which to begin from and the range `r` over which to aggregate [Array](/sql-reference/data-types/array)([Tuple](/sql-reference/data-types/tuple))"},
-        {"x1, x2, ..., xN", "N arrays as arguments to the aggregate function. [Array](/sql-reference/data-types/array)."},
+        {"ranges", "The range over which to aggregate. An array of tuples, `(i, r)` containing the index `i` from which to begin from and the range `r` over which to aggregate [`Array(T)`](/sql-reference/data-types/array)([`Tuple(T1, T2, ...)`](/sql-reference/data-types/tuple))"},
+        {"arr1 [, arr2, ... ,arrN)]", "N arrays as arguments to the aggregate function. [`Array(T)`](/sql-reference/data-types/array)."},
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array containing results of the aggregate function over the specified ranges. [Array](/sql-reference/data-types/array).";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array containing results of the aggregate function over the specified ranges. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", R"(
 SELECT arrayReduceInRanges(
     'sum',

src/Functions/array/arrayReverse.cpp

@@ -247,18 +247,18 @@ bool FunctionArrayReverse::executeString(const IColumn & src_data, const ColumnA
 REGISTER_FUNCTION(ArrayReverse)
 {
     FunctionDocumentation::Description description = R"(
-Reverses an array.
+Reverses the order of elements of a given array.
 
 :::note
-Function `reverse(x)` performs the same functionality but works on other data-types
+Function `reverse(arr)` performs the same functionality but works on other data-types
 in addition to Arrays.
 :::
 )";
-    FunctionDocumentation::Syntax syntax = "arrayReverse(x)";
+    FunctionDocumentation::Syntax syntax = "arrayReverse(arr)";
     FunctionDocumentation::Arguments arguments = {
-        {"x", "An array to reverse. [Array](/sql-reference/data-types/array)"}
+        {"arr", "The array to reverse. [`Array(T)`](/sql-reference/data-types/array)."}
     };
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array of the same size as the original array containing the elements in reverse order. [Array](/sql-reference/data-types/array)";
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array of the same size as the original array containing the elements in reverse order. [`Array(T)`](/sql-reference/data-types/array).";
     FunctionDocumentation::Examples examples = {{"Usage example", "SELECT arrayReverse([1, 2, 3])", "[3,2,1]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {1, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;

src/Functions/array/arrayZip.cpp

@@ -172,20 +172,20 @@ class FunctionArrayZip : public IFunction
 REGISTER_FUNCTION(ArrayZip)
 {
     FunctionDocumentation::Description description = "Combines multiple arrays into a single array. The resulting array contains the corresponding elements of the source arrays grouped into tuples in the listed order of arguments.";
-    FunctionDocumentation::Syntax syntax = "arrayZip(x1, x2, ..., xN)";
-    FunctionDocumentation::Arguments argument = {{"x1, x2, ..., xN", "N arrays to combine into a single array. [`Array`](/sql-reference/data-types/array)"}};
-    FunctionDocumentation::ReturnedValue returned_value = "Returns an array with elements from the source arrays grouped in tuples. Data types in the tuple are the same as types of the input arrays and in the same order as arrays are passed. [`Array`](/sql-reference/data-types/array)([`Tuple`](/sql-reference/data-types/tuple)).";
+    FunctionDocumentation::Syntax syntax = "arrayZip(arr1, arr2, ..., arrN)";
+    FunctionDocumentation::Arguments argument = {{"arr1, arr2, ..., arrN", "N arrays to combine into a single array. [`Array(T)`](/sql-reference/data-types/array)"}};
+    FunctionDocumentation::ReturnedValue returned_value = "Returns an array with elements from the source arrays grouped in tuples. Data types in the tuple are the same as types of the input arrays and in the same order as arrays are passed. [`Array(T)`](/sql-reference/data-types/array)([`Tuple`](/sql-reference/data-types/tuple)).";
     FunctionDocumentation::Examples example = {{"Usage example", "SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);", "[('a',5),('b',2),('c',1)]"}};
     FunctionDocumentation::IntroducedIn introduced_in = {20, 1};
     FunctionDocumentation::Category category = FunctionDocumentation::Category::Array;
     FunctionDocumentation documentation = {description, syntax, argument, returned_value, example, introduced_in, category};
 
     factory.registerFunction<FunctionArrayZip<false>>(documentation);
 
-    FunctionDocumentation::Description description_unaligned = "Combines multiple arrays into a single array, allowing for unaligned arrays (arrays of different lengths). The resulting array contains the corresponding elements of the source arrays grouped into tuples in the listed order of arguments.";
-    FunctionDocumentation::Syntax syntax_unaligned = "arrayZipUnaligned(x1, x2, ..., xN)";
-    FunctionDocumentation::Arguments argument_unaligned = {{"x1, x2, ..., xN", "N arrays to combine into a single array. [`Array`](/sql-reference/data-types/array)."}};
-    FunctionDocumentation::ReturnedValue returned_value_unaligned = "Returns an array with elements from the source arrays grouped in tuples. Data types in the tuple are the same as types of the input arrays and in the same order as arrays are passed. [`Array`](/sql-reference/data-types/array)([`Tuple`](/sql-reference/data-types/tuple)).";
+    FunctionDocumentation::Description description_unaligned = "Combines multiple arrays into a single array, allowing for unaligned arrays (arrays of differing lengths). The resulting array contains the corresponding elements of the source arrays grouped into tuples in the listed order of arguments.";
+    FunctionDocumentation::Syntax syntax_unaligned = "arrayZipUnaligned(arr1, arr2, ..., arrN)";
+    FunctionDocumentation::Arguments argument_unaligned = {{"arr1, arr2, ..., arrN", "N arrays to combine into a single array. [`Array(T)`](/sql-reference/data-types/array)."}};
+    FunctionDocumentation::ReturnedValue returned_value_unaligned = "Returns an array with elements from the source arrays grouped in tuples. Data types in the tuple are the same as types of the input arrays and in the same order as arrays are passed. [`Array(T)`](/sql-reference/data-types/array)([`Tuple(T1, T2, ...)`](/sql-reference/data-types/tuple)).";
     FunctionDocumentation::Examples example_unaligned = {{"Usage example", "SELECT arrayZipUnaligned(['a'], [1, 2, 3]);", "[('a',1),(NULL,2),(NULL,3)]"}};
     FunctionDocumentation::IntroducedIn introduced_in_unaligned = {20, 1};
     FunctionDocumentation::Category category_unaligned = FunctionDocumentation::Category::Array;