List

List prototype extensions

Import

_ <- fat.type.List

Constructor

Name Signature Brief
List (val: Any) Wrap val into a list

Prototype members

Name Signature Brief
isEmpty (): Boolean Returns true if length is zero
nonEmpty (): Boolean Returns true if length is non-zero
size (): Number Returns list length
toText (): Text Returns 'List' as text literal
join (sep: Text): Text Joins list with separator into text
flatten (): List Flattens list of lists into one list
find (p: Method): Any Returns first matching item or null
contains (p: Method): Boolean Checks if list contains match for predicate
filter (p: Method): List Returns sub-list matching predicate
reverse (): List Returns a reversed copy of the list
shuffle (): List Returns a shuffled copy of the list
unique (): List Returns a list of unique items
sort (): List Returns a sorted copy of the list
sortBy (key: Any): List Returns a sorted copy of the list *
indexOf (item: Any): Number Returns item index, -1 if absent
head (): Any Returns first item, null if empty
tail (): List Returns all items, but the first
map (m: Method): List Functional utility (allows chaining)
reduce (m: Method, acc: Any): Any Functional utility
walk (m: Method): Void Apply side-effects to each item
patch (i, n, val: List): List Inserts val at position i, removing n items
headOption (): Option Returns first item, as Option
itemOption (index: Number): Option Get item by index, as Option
findOption (p: Method): Option Search item by predicate, as Option

Example

_ <- fat.type.List
x = [ 'a', 'b', 'c' ]
x.size  # yields 3

Sorting

The sort and sortBy methods implement the quicksort algorithm, enhanced with random pivot selection. This approach is known for its efficiency, offering an average-case time complexity of O(n log n). It demonstrates high performance across most datasets. For datasets containing duplicate values or keys, stable sorting cannot be guaranteed, and performance may degrade to O(n^2) in the worst case, where all elements are identical or have the same key.

sortBy accepts a textual parameter for key if it is a list of Scope, or a numerical parameter if it is a list of List (matrix), representing the index

Reducing

The reduce method in FatScript transforms a list into a single value by applying a reducer (m: Method) to each element in sequence, starting from an initial accumulator value (acc: Any), or from the first element if no value is provided. This method is useful for operations that involve aggregating data from a list.

Characteristics

  • Reducer Method: The reducer should take the current accumulator value and the current list item, returning the updated accumulator value.

  • Empty List Behavior: When reduce is applied to an empty list without an initial accumulator value, it returns null.

Practical Example

_ <- fat.type.List
sumReducer = (acc: Number, item: Number) -> acc + item
sum = [1, 2, 3].reduce(sumReducer)  # yields 6

for complex data transformations or when dealing with lists of scopes, carefully structure the reducer to handle the specific data types and desired output

See Also

results matching ""

    No results matching ""