add flatten function

builtin/builtin.go

@@ -873,6 +873,37 @@ var Builtins = []*Function{
  return arrayType, nil
  },
 	},
+	{
+ Name: "flatten",
+ Safe: func(args ...any) (any, uint, error) {
+ var size uint
+ if len(args) != 1 {
+ return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+ }
+ v := reflect.ValueOf(deref.Deref(args[0]))
+ if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
+ return nil, size, fmt.Errorf("cannot flatten %s", v.Kind())
+ }
+ ret := flatten(v)
+ size = uint(len(ret))
+ return ret, size, nil
+ },
+ Validate: func(args []reflect.Type) (reflect.Type, error) {
+ if len(args) != 1 {
+ return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+ }
+
+ for _, arg := range args {
+ switch kind(deref.Type(arg)) {
+ case reflect.Interface, reflect.Slice, reflect.Array:
+ default:
+ return anyType, fmt.Errorf("cannot flatten %s", arg)
+ }
+ }
+
+ return arrayType, nil
+ },
+	},
 	{
  Name: "sort",
  Safe: func(args ...any) (any, uint, error) {

builtin/builtin_test.go

@@ -152,6 +152,9 @@ func TestBuiltin(t *testing.T) {
  {`reduce([], 5, 0)`, 0},
  {`concat(ArrayOfString, ArrayOfInt)`, []any{"foo", "bar", "baz", 1, 2, 3}},
  {`concat(PtrArrayWithNil, [nil])`, []any{42, nil}},
+ {`flatten([["a", "b"], [1, 2]])`, []any{"a", "b", 1, 2}},
+ {`flatten([["a", "b"], [1, 2, [3, 4]]])`, []any{"a", "b", 1, 2, 3, 4}},
+ {`flatten([["a", "b"], [1, 2, [3, [[[["c", "d"], "e"]]], 4]]])`, []any{"a", "b", 1, 2, 3, "c", "d", "e", 4}},
 	}
 
 	for _, test := range tests {
@@ -236,6 +239,8 @@ func TestBuiltin_errors(t *testing.T) {
  {`now(nil)`, "invalid number of arguments (expected 0, got 1)"},
  {`date(nil)`, "interface {} is nil, not string (1:1)"},
  {`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"},
+ {`flatten([1, 2], [3, 4])`, "invalid number of arguments (expected 1, got 2)"},
+ {`flatten(1)`, "cannot flatten int"},
 	}
 	for _, test := range errorTests {
  t.Run(test.input, func(t *testing.T) {

builtin/lib.go

@@ -359,3 +359,17 @@ func median(args ...any) ([]float64, error) {
 	}
 	return values, nil
 }
+
+func flatten(arg reflect.Value) []any {
+	ret := []any{}
+	for i := 0; i < arg.Len(); i++ {
+ v := deref.Value(arg.Index(i))
+ if v.Kind() == reflect.Array || v.Kind() == reflect.Slice {
+ x := flatten(v)
+ ret = append(ret, x...)
+ } else {
+ ret = append(ret, v.Interface())
+ }
+	}
+	return ret
+}

docs/language-definition.md

@@ -689,6 +689,14 @@ Concatenates two or more arrays.
 concat([1, 2], [3, 4]) == [1, 2, 3, 4]
 ```
 
+### flatten(array) {#flatten}
+
+Flattens given array into one-dimentional array.
+
+```expr
+flatten([1, 2, [3, 4]]) == [1, 2, 3, 4]
+```
+
 ### join(array[, delimiter]) {#join}
 
 Joins an array of strings into a single string with the given delimiter.