Class Lists

Inserts an item at a specific position in the list. Example: In [10, 20, 30, 40], adding 99 at index 2 gives [10, 20, 99, 30, 40]

Inserts the same item at multiple specified positions in the list. Example: In [10, 20, 30], adding 99 at indexes [0, 2] gives [99, 10, 20, 99, 30]

Inserts multiple items at corresponding positions (first item at first index, second item at second index, etc.). Example: In [10, 20, 30], adding items [88, 99] at indexes [1, 2] gives [10, 88, 20, 99, 30]

Appends an item to the end of the list. Example: To [10, 20, 30], adding 40 gives [10, 20, 30, 40]

Adds an item to the beginning of the list. Example: To [10, 20, 30], prepending 5 gives [5, 10, 20, 30]

Adds an item either at the beginning or end of the list based on the position parameter. Example: To [10, 20, 30], adding 5 at 'first' gives [5, 10, 20, 30], at 'last' gives [10, 20, 30, 5]

Combines multiple lists into a single list by joining them end-to-end. Example: From [[1, 2], [3, 4], [5, 6]], returns [1, 2, 3, 4, 5, 6]

Creates a new empty list with no items. Example: Returns []

Creates a new list by repeating an item a specified number of times. Example: Repeating 5 three times returns [5, 5, 5]

Repeats a pattern of items cyclically until reaching a target list length. Example: Pattern [1, 2, 3] with length 7 returns [1, 2, 3, 1, 2, 3, 1]

Reverses the order of items in the list. Example: From [1, 2, 3, 4, 5], returns [5, 4, 3, 2, 1]

Randomly rearranges all items in the list (using Fisher-Yates algorithm). Example: From [1, 2, 3, 4, 5], might return [3, 1, 5, 2, 4] (order varies each time)

Transposes a 2D list by swapping rows and columns (all sublists must be equal length). Example: From [[0, 1, 2], [3, 4, 5]], returns [[0, 3], [1, 4], [2, 5]]

Splits the list into smaller lists of n elements each. Example: From [0, 1, 2, 3, 4, 5, 6, 7, 8] with n=3, returns [[0, 1, 2], [3, 4, 5], [6, 7, 8]] Example: From [0, 1, 2, 3, 4] with n=2 and keepRemainder=true, returns [[0, 1], [2, 3], [4]]

Gets an item from the list at a specific position using zero-based indexing. Example: From [10, 20, 30, 40], getting index 2 returns 30

Gets the first item from the list. Example: From [10, 20, 30, 40], returns 10

Gets the last item from the list. Example: From [10, 20, 30, 40], returns 40

Randomly keeps items from the list based on a probability threshold (0 to 1). Example: From [1, 2, 3, 4, 5] with threshold 0.5, might return [1, 3, 5] (50% chance for each item)

Extracts a portion of the list between start and end positions (end is exclusive). Example: From [10, 20, 30, 40, 50] with start=1 and end=4, returns [20, 30, 40]

Gets every nth item from the list, starting from an optional offset position. Example: From [0, 1, 2, 3, 4, 5, 6, 7, 8] with nth=3 and offset=0, returns [0, 3, 6] Example: From [0, 1, 2, 3, 4, 5, 6, 7, 8] with nth=2 and offset=1, returns [1, 3, 5, 7]

Filters items from the list using a repeating true/false pattern. Example: From [0, 1, 2, 3, 4, 5] with pattern [true, true, false], returns [0, 1, 3, 4] (keeps items where pattern is true)

Merges elements from multiple lists at a specific nesting level, grouping elements by position. Example: From [[0, 1, 2], [3, 4, 5]] at level 0, returns [[0, 3], [1, 4], [2, 5]]

Finds the length of the longest list among multiple lists. Example: From [[1, 2], [3, 4, 5, 6], [7]], returns 4 (length of [3, 4, 5, 6])

Checks whether the list contains a specific item. Example: List [10, 20, 30, 40] with item 30 returns true, with item 50 returns false

Finds the position (index) of the first occurrence of an item in the list. Example: In [10, 20, 30, 20, 40], finding 20 returns 1 (first occurrence), finding 50 returns -1 (not found)

Determines the maximum nesting level (depth) of a list structure. Example: [1, 2, 3] has depth 1, [[1, 2], [3, 4]] has depth 2, [[[1]]] has depth 3

Returns the number of items in the list. Example: [10, 20, 30, 40, 50] returns 5, [] returns 0

Removes the item at a specific position in the list. Example: From [10, 20, 30, 40, 50], removing index 2 gives [10, 20, 40, 50]

Removes the first item from the list. Example: From [10, 20, 30, 40], returns [20, 30, 40]

Removes the last item from the list. Example: From [10, 20, 30, 40], returns [10, 20, 30]

Removes an item counting from the end of the list (index 0 = last item, 1 = second-to-last, etc.). Example: From [10, 20, 30, 40, 50], removing index 1 from end gives [10, 20, 30, 50] (removes 40)

Removes items at multiple specified positions from the list. Example: From [10, 20, 30, 40, 50], removing indexes [1, 3] gives [10, 30, 50]

Clears all items from the list, resulting in an empty list. Example: From [10, 20, 30, 40], returns []

Removes every nth item from the list, starting from an optional offset position. Example: From [0, 1, 2, 3, 4, 5, 6, 7, 8] with nth=3 and offset=0, returns [1, 2, 4, 5, 7, 8] (removes 0, 3, 6)

Randomly removes items from the list based on a probability threshold (0 to 1). Example: From [1, 2, 3, 4, 5] with threshold 0.5, might return [2, 4] (50% chance to remove each item)

Removes duplicate numbers from the list, keeping only the first occurrence of each value. Example: From [1, 2, 3, 2, 4, 3, 5], returns [1, 2, 3, 4, 5]

Removes duplicate numbers that are within a specified tolerance range of each other. Example: From [1.0, 1.001, 2.0, 2.002, 3.0] with tolerance 0.01, returns [1.0, 2.0, 3.0]

Removes duplicate items from the list using strict equality comparison (works with any type). Example: From ['a', 'b', 'c', 'a', 'd', 'b'], returns ['a', 'b', 'c', 'd']

Sorts numbers in ascending (lowest to highest) or descending (highest to lowest) order. Example: [5, 2, 8, 1, 9] ascending returns [1, 2, 5, 8, 9], descending returns [9, 8, 5, 2, 1]

Sorts text strings alphabetically in ascending (A to Z) or descending (Z to A) order. Example: ['dog', 'apple', 'cat', 'banana'] ascending returns ['apple', 'banana', 'cat', 'dog']

Sorts objects by comparing numeric values of a specified property. Example: [{age: 30}, {age: 20}, {age: 25}] sorted by 'age' ascending returns [{age: 20}, {age: 25}, {age: 30}]

Combines multiple lists by alternating elements from each list (first from list1, first from list2, second from list1, etc.). Example: From [[0, 1, 2], [3, 4, 5]], returns [0, 3, 1, 4, 2, 5]