class Arrays

Finds the first occurrance of element and returns all the elements after it.

Checks if predicate returns true for all elements in the array.

Checks if predicate returns true for at least one element in the array.

Arrays.add pushes an element at the end of the array and returns it. Practical for chaining push operations.

Arrays.addIf conditionaly pushes an element at the end of the array and returns it. Practical for chaining push operations.

Arrays.applyIndexes takes an array and returns a copy of it with its elements rearranged according to indexes.

If the indexes array does not contain continuous values, you may want to set incrementDuplicates to true.

var result = Arrays.applyIndexes(["B", "C", "A"], [1, 2, 0]); trace(result); // output ["A", "B", "C"]

Creates an array of elements from the specified indexes.

Safe indexed access to array elements. Deprecated in favor of getOption.

Finds the first occurrance of element and returns all the elements before it.

Traverse both arrays from the beginning and collect the elements that are the same. It stops as soon as the arrays differ.

Filters out all null elements in the array

Compares two arrays returning a negative integer, zero or a positive integer.

The first comparison is made on the array length.

If they match each pair of elements is compared using thx.Dynamics.compare.

Returns true if all items in elements are found in the array.

An optional equality function can be passed as the last argument. If not provided, strict equality is adopted.

Returns true if all items in elements are found in the array and they are a strict match or matched by the provided eq function.

An optional equality function can be passed as the last argument. If not provided, strict equality is adopted.

Returns true if any element in elements is found in the array.

An optional equality function can be passed as the last argument. If not provided, strict equality is adopted.

Returns true if any element in elements is found in the array and it is a strict match or matched by the provided eq function.

An optional equality function can be passed as the last argument. If not provided, strict equality is adopted.

Returns true if element is found in the array.

Returns true if element is found in the array and it is a strict match or matched by the provided eq function.

Returns a Map containing the number of occurrances for each value in the array.

Creates a new Array with length elements all set to fillWith.

It returns the cross product between two arrays.

var r = [1,2,3].cross([4,5,6]);
trace(r); // [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]

It produces the cross product of each array element.

var r = [[1,2],[3,4],[5,6]].crossMulti();
trace(r); // [[1,3,5],[2,3,5],[1,4,5],[2,4,5],[1,3,6],[2,3,6],[1,4,6],[2,4,6]]

Returns a new array containing only unique values from the input array. Input array does not need to be sorted. A predicate comparison function can be provided for comparing values. Default comparison is ==.

Produces an Array from a[n] to the last element of a.

Produces an Array from a[0] to a[a.length-n].

Drops values from Array a while the predicate returns true.

Applies a side-effect function to all elements in the array.

It allows to iterate an array pairing each element with every other element in the array.

The iteration ends as soon as the callback returns false.

Applies a side-effect function to all elements in the array.

It compares the lengths and elements of two given arrays and returns true if all elements match.

An optional equality function can be passed as the last argument. If not provided, strict equality is adopted.

It finds an element in the array using predicate and returns it. The element is also removed from the original array.

If no element satisfies predicate the array is left unmodified and null is returned.

Fills null values in arr with def.

Performs a filter and map operation at once. It uses predicate to get either None or a transformed value Some of TOut.

Filters out all null values from an array.

Filters out all None values from an array and extracts Some(value) to value.

It returns the first element of the array that matches the predicate function. If none is found it returns null.

It returns the index of the first element of the array that matches the predicate function. If none is found it returns -1.

It returns the last element of the array that matches the provided predicate function. If none is found it returns null.

Finds the first item in an array where the given function f returns a Option.Some value. If no items map to Some, None is returned.

It returns the first element of the array that matches the predicate function. If none is found it returns null.

Finds the first item in an Array<Option<T>> that is Some, otherwise None.

Like find, but each item's index is also passed to the predicate.

Like findOption, but each item's index is also passed to the predicate.

It returns the first element of the array or null if the array is empty.

It returns an option of the first element or None if the array is empty.

It traverses an array of elements. Each element is split using the callback function and a 'flattened' array is returned.

var chars = ['Hello', 'World'].flatMap(function(s) return s.split(''));
trace(chars); // ['H','e','l','l','o','W','o','r','l','d']

It takes an array of arrays and 'flattens' it into an array.

var arr = [[1,2,3],[4,5,6],[7,8,9]];
trace(arr); // [1,2,3,4,5,6,7,8,9]

Converts an Array<Option<T>> to Option<Array<T>> only if all elements in the input array contain a Some value. The input and the output array (if any) will have the same length.

Reduce with a monoid

Alias for reduce that puts the arguments in the proper order.

As with foldLeft, but uses first element as Init.

Fold by mapping the contained values into some monoidal type and reducing with that monoid.

Reduce with a semigroup, returning None if the array is empty.

Finds the first occurrance of element and returns all the elements from that point on.

Creates an Array<T> containing the given item

Safe indexed access to array elements. Null values within array will also return None instead of Some(null).

Returns a Map of arrays. Each value in the array is passed to resolver that returns a key to use to group such element.

This method is tagged with @:generic and needs a compatible type to be used (ex: no anonymous objects).

In case you have to use a type that is not supported by @:generic, please use groupByAppend.

Each value in the array is passed to resolver that returns a key to use to group such element. Groups are appended to the passed map.

Group the array by a function of the index.

Returns true if the array contains at least one element.

It returns the first element of the array or null if the array is empty. Same as first.

ifEmpty returns array if it is neither null or empty, otherwise it returns alt

Get all the elements from array except for the last one.

Creates a new array that alternates the values in array with value.

Lazy version of intersperse. It creates a new array that alternates the values in array with the result of f.

It returns true if the array contains zero elements.

It returns the last element of the array or null if the array is empty.

It returns an option of the last element, None if the array is empty.

Static wrapper for Array map function.

Same as Array.map but traverses the array from the last to the first element.

Same as Array.map but it adds a second argument to the callback function with the current index value.

Finds the min element of the array given the specified ordering.

Finds the min element of the array given the specified ordering.

The concatenation monoid for arrays.

Safely convert to a non-empty list.

It works the same as Array.sort() but doesn't change the original array and returns a sorted copy it.

Pads out to len with optional default def, ignores if len is less than Array length.

Produces a Tuple2 containing two Array, the left being elements where f(e) == true, the rest in the right.

Produces a Tuple2 containing two Arrays, the difference from partition being that after the predicate returns true once, the rest of the elements will be in the right hand of the tuple, regardless of the result of the predicate.

Pulls from array all occurrences of all the elements in toRemove. Optionally takes an equality function.

It pushes value onto the array if condition is true. Also returns the array for easy method chaining.

Given an array of values, it returns an array of indexes permutated applying the function compare.

By default rank will return continuous values. If you know that your set does not contain duplicates you might want to turn off that feature by setting incrementDuplicates to false.

var arr = ["C","A","B"];
var indexes = Arrays.rank(arr, Strings.compare);
trace(indexes); // output [2,0,1]

It applies a function against an accumulator and each value of the array (from left-to-right) has to reduce it to a single value.

Same as Arrays.reduce but starting from the last element and traversing to the first

It is the same as reduce but with the extra integer index parameter.

Remove every occurrance of element from array. If equality is not specified, strict equality will be adopted.

Resizes an array of T to an arbitrary length by adding more elements to its end or by removing extra elements.

Note that the function changes the passed array and doesn't create a copy.

Copies and resizes an array of T to an arbitrary length by adding more elements to its end or by removing extra elements.

Note that the function creates and returns a copy of the passed array.

Returns all but the first element of the array

Creates a copy of the array with its elements in reverse order.

Transforms an array like [[a0,b0],[a1,b1],[a2,b2]] into [[a0,a1,a2],[b0,b1,b2]].

Returns n elements at random from the array. Elements will not be repeated.

Returns one element at random from the array or null if the array is empty.

It returns a copy of the array with its elements randomly changed in position.

Splits an array into a specified number of parts.

Splits an array into smaller arrays at most of length equal to len.

Splits an array by the given number and pads last group with the given element if necessary.

Converts an Array<T> into a string.

It returns the elements of the array after the first.

Returns the first n elements from the array.

Returns the last n elements from the array.

Convert an array of tuples to a map. If there are collisions between keys, return an error.

Traverse the array with a function that may return values wrapped in Either. If any result is in Left, the first such value is returned; if all results are in Right, then the array of those results is returned in Right.

If you want to instead collect errors rather than fail on the first error, see traverseValidation.

Traverse the array with a function that may return values wrapped in Option. If any of the values are None, return None, otherwise return the array of mapped values in a Some.

Traverse the array with a function that may return values wrapped in Validation. If any of the values are Failures, return a Failure that accumulates all errors from the failed values, otherwise return the array of mapped values in a Success.

Traverse the array with a function that may return values wrapped in Validation. If any of the values are Failures, return a Failure that accumulates all errors from the failed values, otherwise return the array of mapped values in a Success.

Unzip an array of Tuple2 to a Tuple2, Array>.

Unzip an array of Tuple3 to a Tuple3, Array, Array>.

Unzip an array of Tuple4 to a Tuple4, Array, Array, Array>.

Unzip an array of Tuple5 to a Tuple5, Array, Array, Array, Array>.

Returns a copy of the array with the new element added to the end.

Returns a copy of the array with the new element inserted at position pos.

Returns a copy of the array with the new element added to the beginning.

Returns a copy of the array with the other elements inserted at start. The length elements after start are going to be removed.

Pairs the elements of two arrays in an array of Tuple2.

Zip two arrays by applying the provided function to the aligned members.

Pairs the elements of three arrays in an array of Tuple3.

Zip three arrays by applying the provided function to the aligned members.

Pairs the elements of four arrays in an array of Tuple4.

Zip four arrays by applying the provided function to the aligned members.

Pairs the elements of five arrays in an array of Tuple5.

Zip five arrays by applying the provided function to the aligned members.

The 'zip' applicative functor operation.