@platforma-sdk/workflow-tengo 2.9.6 → 2.9.7

package/dist/tengo/lib/slices.lib.tengo

@@ -1,202 +1,305 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 enum := import("enum")
 
-
-
-
-
-
-
-
+/**
+ * Returns length of the collection even if it's nil.
+ * It's a one of rare differences of Tengo and Go.
+ *
+ * @param slice: []any | undefined - a slice
+ * @return: length: int
+ */
 length := func(slice) {
-if is_undefined(slice) {
-return 0
+	if is_undefined(slice) {
+		return 0
+	}
+	return len(slice)
 }
-return len(slice)
-}
-
-
-
-
-
-
-
-
-
-
 
+/**
+ * Returns a slice of the array, but you can give negative from and to,
+ * in which case it slices from the end like in Python.
+ * Example: slice([1, 2, 3], 0, -1) == [1, 2]
+ *
+ * @param array: []any - a slice
+ * @param from: number - an index we starts from
+ * @param to: number - an index the slice will end
+ * @return slice: []any - a sliced array.
+ */
 slice := func(array, from, to) {
-len := length(array)
-if from < 0 {
-from = len + from
-}
-if to < 0 {
-to = len + to
+	len := length(array)
+	if from < 0 {
+		from = len + from
+	}
+	if to < 0 {
+		to = len + to
+	}
+
+	return array[from:to]
 }
 
-return array[from:to]
-}
-
-
-
-
-
-
-
-
-
+/**
+ * Appends slices safely even some of them are nil.
+ * It's one of rare differences of Tengo and Go.
+ *
+ * @param slice: []any - a slice
+ * @param toAppend: ...any - elements we'll append to the slice
+ * @return new slice: []any - the same slice but with appended elements.
+ */
 safeAppend := func(slice, ...toAppend) {
-if is_undefined(slice) {
-slice = []
-}
-if length(toAppend) == 0 {
-return slice // slice is of any length here.
+	if is_undefined(slice) {
+		slice = []
+	}
+	if length(toAppend) == 0 {
+		return slice // slice is of any length here.
+	}
+
+	return append(slice, toAppend...)
 }
 
-return append(slice, toAppend...)
-}
-
-
-
-
-
-
-
-
+/**
+ * Returns an index of an element in the slice or -1 if it wasn't found.
+ *
+ * @param silce: []any
+ * @param element: any
+ * @return index: int - index of the element or -1
+ */
 findElement := func(slice, element) {
-for i, elem in slice {
-if elem == element {
-return i
-}
-}
+	for i, elem in slice {
+		if elem == element {
+			return i
+		}
+	}
 
-return -1
+	return -1
 }
 
-
-
-
-
-
-
-
+/**
+ * Returns a boolean of whether an element is in a slice.
+ *
+ * @param slice: []any
+ * @param element: any - an element the function searches for.
+ * @return found: bool
+ */
 hasElement := func(slice, element) {
-return findElement(slice, element) != -1
+	return findElement(slice, element) != -1
 }
 
-
-
-
-
-
-
-
+/**
+ * Removes an element from the slice
+ *
+ * @param slice: []any
+ * @param i: int - an index of the element to remove.
+ * @return nothing
+ */
 removeElement := func(slice, i) {
-return safeAppend(slice[:i], slice[i+1:]...)
+	return safeAppend(slice[:i], slice[i+1:]...)
 }
 
-
-
-
-
-
-
-
+/**
+ * Returns a new slice with elements for which a predicate returned true.
+ *
+ * @param slice: []any
+ * @param predicateFn: func(elem): bool - a function that gets an element and returns a truthy or falsy value.
+ * @return new slice: []any - a slice with matched elements.
+ */
 filter := func(slice, predicateFn) {
-newS := []
-for _, elem in slice {
-if predicateFn(elem) {
-newS = append(newS, elem)
-}
-}
-
-return newS
+	newS := []
+	for _, elem in slice {
+		if predicateFn(elem) {
+			newS = append(newS, elem)
+		}
+	}
+
+	return newS
 }
 
-
-
-
-
-
-
-
+/**
+ * Transforms each element of the slice to a new one and returns a new slice
+ *
+ * @param slice: []any
+ * @param fn: func(elem): new elem - a function that gets an element and returns a transformed element.
+ * @return new slice: []any - a new slice with transformed elements.
+ */
 map := func(slice, fn) {
-newS := []
-for _, elem in slice {
-newS = append(newS, fn(elem))
-}
+	newS := []
+	for _, elem in slice {
+		newS = append(newS, fn(elem))
+	}
 
-return newS
+	return newS
 }
 
-
-
-
-
-
-
-
-
-
-
+/**
+ * Returns the result of applying fn to the first 2 items in the slice, then
+ * applying fn to that result and the 3rd item, etc.
+ * If coll has only 1 item, it is returned and fn is not called.
+ *
+ * @param slice: []any
+ * @param fn: func(any, element): new result.
+ * a function that gets a result got so far and an element and returns a new result.
+ * @return final result: any - the final result
+ */
 reduce := func(slice, fn) {
-result := undefined
-for i, elem in slice {
-if i == 0 {
-result = elem
-} else {
-result = fn(result, elem)
-}
+	result := undefined
+	for i, elem in slice {
+		if i == 0 {
+			result = elem
+		} else {
+			result = fn(result, elem)
+		}
+	}
+
+	return result
 }
 
-return result
+//
+// Simple quick-sort implementations:
+//   - with user-provided ordering
+//   - and with native sorting
+//
+
+_quickSortFn := func(arr, left, right, less) {
+    if is_undefined(arr) || len(arr) <= 1 || left < 0 || left >= len(arr) || right < 0 || right >= len(arr) || left >= right {
+        return arr
+    }
+    idx := left
+    for i := left; i < right; i++ {
+        if less(arr[i], arr[right]) {
+			temp := arr[i]
+			arr[i] = arr[idx]
+			arr[idx] = temp
+            idx++
+        }
+    }
+	temp := arr[right]
+	arr[right] = arr[idx]
+	arr[idx] = temp
+    _quickSortFn(arr, left, idx-1, less)
+    _quickSortFn(arr, idx+1, right, less)
+    return arr
 }
 
-
-
-
-
-
-
-
-
-sortByFn := func(notSortedSlice, fn) {
-s := copy(notSortedSlice)
-
-for i := 0; i < length(s) - 1; i++ {
-for j := i+1; j < length(s); j++ {
-if fn(s[i]) > fn(s[j]) {
-tmp := s[i]
-s[i] = s[j]
-s[j] = tmp
-}
-}
+_quickSort := func(arr, left, right) {
+    if is_undefined(arr) || len(arr) <= 1 || left < 0 || left >= len(arr) || right < 0 || right >= len(arr) || left >= right {
+        return arr
+    }
+    idx := left
+    for i := left; i < right; i++ {
+        if arr[i] < arr[right] {
+			temp := arr[i]
+			arr[i] = arr[idx]
+			arr[idx] = temp
+            idx++
+        }
+    }
+	temp := arr[right]
+	arr[right] = arr[idx]
+	arr[idx] = temp
+    _quickSort(arr, left, idx-1)
+    _quickSort(arr, idx+1, right)
+    return arr
 }
 
-return s
+/**
+ * Sorts slice in-place, using native ordering.
+ *
+ * @param s: []any - a slice of elements of any comparable type
+ * @return s: []any the same slice after sorting
+ *
+ */
+quickSortInPlace := func(s) {
+	_quickSort(s, 0, len(s)-1)
+	return s
 }
 
+/**
+ * Copy the slice and returtn sorted slice according to native ordering.
+ *
+ * @param s: []any - a slice of elements of any comparable type
+ * @return s: []any sorted slice
+ *
+ */
+quickSort := func(s) {
+	s = copy(s)
+	_quickSort(s, 0, len(s)-1)
+	return s
+}
 
+/**
+ * Sorts slice in-place, using provided ordering function.
+ *
+ * @param s: []any - a slice of elements of any comparable type
+ * @param less: func(a, b): boolean - define ordering, must return true, if a < b
+ * @return s: []any the same slice after sorting
+ */
+quickSortInPlaceFn := func(s, less) {
+	_quickSortFn(s, 0, len(s)-1, less)
+	return s
+}
 
+/**
+ * Copy the slice and returtn sorted slice according to using provided ordering function.
+ *
+ * @param s: []any - a slice of elements of any comparable type
+ * @param less: func(a, b): boolean - define ordering, must return true, if a < b
+ * @return s: []any sorted slice
+ *
+ */
+quickSortFn := func(s, less) {
+	s = copy(s)
+	_quickSortFn(s, 0, len(s)-1, less)
+	return s
+}
 
+/**
+ * Creates a copy of a slice and sorts it using a stable bubble sort.
+ *
+ * @param notSortedSlice: []any - a slice of elements of any type.
+ * @param fn: func(elem): int - a function that transforms an element to a key.
+ * @return sorted slice: []any
+ *
+ */
+sortByFn := func(notSortedSlice, fn) {
+	s := copy(notSortedSlice)
+
+	for i := 0; i < length(s) - 1; i++ {
+		for j := i+1; j < length(s); j++ {
+			if fn(s[i]) > fn(s[j]) {
+				tmp := s[i]
+				s[i] = s[j]
+				s[j] = tmp
+			}
+		}
+	}
+
+	return s
+}
 
-
-
+/**
+ * Creates a slice from a set of elements
+ *
+ * @param set: map[element]any - a set
+ * @return slice: []element - a slice of elements from the set, sorted by an element.
+ */
 fromSet := func(set) {
-slice := enum.map(set, func(k, _) { return k })
-return sortByFn(slice, func(elem) { return elem })
+	slice := enum.map(set, func(k, _) { return k })
+	return sortByFn(slice, func(elem) { return elem })
 }
 
 export ll.toStrict({
-length: length,
-safeAppend: safeAppend,
-findElement: findElement,
-hasElement: hasElement,
-removeElement: removeElement,
-filter: filter,
-map: map,
-reduce: reduce,
-sortByFn: sortByFn,
-fromSet: fromSet,
-slice: slice
+	length: length,
+	safeAppend: safeAppend,
+	findElement: findElement,
+	hasElement: hasElement,
+	removeElement: removeElement,
+	filter: filter,
+	map: map,
+	reduce: reduce,
+	quickSortInPlace: quickSortInPlace,
+	quickSort: quickSort,
+	quickSortFn: quickSortFn,
+	quickSortInPlaceFn: quickSortInPlaceFn,
+	sortByFn: sortByFn,
+	fromSet: fromSet,
+	slice: slice
 })