Creates a new array with the given length.
Creates a new array with the given length.
Initial length of the array.
Creates a new array of length 0.
(Changed in version 2.8.0) ++ creates a new buffer. Use ++= to add an element from this buffer and return that buffer itself.
(Changed in version 2.8.0) - creates a new buffer. Use -= to remove an element from this buffer and return that buffer itself.
(Changed in version 2.8.0) - creates a new buffer. Use -= to remove an element from this buffer and return that buffer itself.
(Changed in version 2.8.0) -- creates a new buffer. Use --= to remove an element from this buffer and return that buffer itself.
Access the element at the given index.
Access the element at the given index.
concat creates a new array consisting of the elements in the this object on which it is called, followed in order by, for each argument, the elements of that argument (if the argument is an array) or the argument itself (if the argument is not an array).
concat creates a new array consisting of the elements in the this object on which it is called, followed in order by, for each argument, the elements of that argument (if the argument is an array) or the argument itself (if the argument is not an array).
MDN
Tests whether this object has the specified property as a direct property.
Tests whether this object has the specified property as a direct property.
Unlike js.Object.hasProperty, this method does not check down the object's prototype chain.
MDN
Tests whether this object is in the prototype chain of another object.
Tests whether this object is in the prototype chain of another object.
The join() method joins all elements of an array into a string.
The join() method joins all elements of an array into a string.
separator Specifies a string to separate each element of the array. The separator is converted to a string if necessary. If omitted, the array elements are separated with a comma.
ECMAScript 6 JavaScript Iterator for this Array.
ECMAScript 6 JavaScript Iterator for this Array.
The slice() method returns a shallow copy of a portion of an array.
The slice() method returns a shallow copy of a portion of an array.
MDN
Length of the array.
Sets the length of the array.
Sets the length of the array.
If the new length is bigger than the old length, created slots are
filled with undefined (irrespective of the type argument A!).
If the new length is smaller than the old length, the array is shrunk.
The pop() method removes the last element from an array and returns that element.
The pop() method removes the last element from an array and returns that element.
MDN
Tests whether the specified property in an object can be enumerated by a call to js.Object.properties, with the exception of properties inherited through the prototype chain.
Tests whether the specified property in an object can be enumerated by a call to js.Object.properties, with the exception of properties inherited through the prototype chain. If the object does not have the specified property, this method returns false.
MDN
The push() method mutates an array by appending the given elements and returning the new length of the array.
The push() method mutates an array by appending the given elements and returning the new length of the array.
MDN
The reverse() method reverses an array in place.
The reverse() method reverses an array in place. The first array element becomes the last and the last becomes the first.
MDN
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
The shift() method removes the first element from an array and returns that element.
The shift() method removes the first element from an array and returns that element. This method changes the length of the array.
MDN
The sort() method sorts the elements of an array in place and returns the array.
The sort() method sorts the elements of an array in place and returns the array. The sort is not necessarily stable. The default sort order is lexicographic (not numeric).
If compareFunction is not supplied, elements are sorted by converting them to strings and comparing strings in lexicographic ("dictionary" or "telephone book," not numerical) order. For example, "80" comes before "9" in lexicographic order, but in a numeric sort 9 comes before 80.
MDN
Removes and adds new elements at a given index in the array.
Removes and adds new elements at a given index in the array.
This method first removes deleteCount elements starting from the index
index, then inserts the new elements items at that index.
If index is negative, it is treated as that number of elements starting
from the end of the array.
Index where to start changes
Number of elements to delete from index
Elements to insert at index
An array of the elements that were deleted
The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.
The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.
MDN
Set the element at the given index.
Set the element at the given index.
(array: ArrayOps[A]).++=(xs)
(array: WrappedArray[A]).++=(xs)
(array: ArrayOps[A]).+=(elem)
(array: ArrayOps[A]).+=(elem1, elem2, elems)
(array: WrappedArray[A]).+=(elem)
(array: WrappedArray[A]).+=(elem1, elem2, elems)
(array: ArrayOps[A])./:(z)(op)
(array: WrappedArray[A])./:(z)(op)
(array: IterableOps[A])./:(z)(op)
(array: ArrayOps[A]).:\(z)(op)
(array: WrappedArray[A]).:\(z)(op)
(array: IterableOps[A]).:\(z)(op)
(array: ArrayOps[A]).addString(b)
(array: ArrayOps[A]).addString(b, sep)
(array: ArrayOps[A]).addString(b, start, sep, end)
(array: WrappedArray[A]).addString(b)
(array: WrappedArray[A]).addString(b, sep)
(array: WrappedArray[A]).addString(b, start, sep, end)
(array: IterableOps[A]).addString(b)
(array: IterableOps[A]).addString(b, sep)
(array: IterableOps[A]).addString(b, start, sep, end)
(array: ArrayOps[A]).aggregate(z)(seqop, combop)
(array: WrappedArray[A]).aggregate(z)(seqop, combop)
(array: IterableOps[A]).aggregate(z)(seqop, combop)
(array: ArrayOps[A]).apply(index)
(array: WrappedArray[A]).apply(index)
(array: ArrayOps[A]).canEqual(that)
(array: WrappedArray[A]).canEqual(that)
(array: IterableOps[A]).canEqual(that)
(array: ArrayOps[A]).clear()
(array: WrappedArray[A]).clear()
(array: WrappedArray[A]).clone()
(array: WrappedArray[A]).collect(pf)(bf)
(array: IterableOps[A]).collect(pf)(bf)
(array: ArrayOps[A]).collectFirst(pf)
(array: WrappedArray[A]).collectFirst(pf)
(array: IterableOps[A]).collectFirst(pf)
(array: ArrayOps[A]).combinations(n)
(array: WrappedArray[A]).combinations(n)
(array: WrappedArray[A]).companion
(array: IterableOps[A]).companion
(array: ArrayOps[A]).contains(elem)
(array: WrappedArray[A]).contains(elem)
(array: ArrayOps[A]).containsSlice(that)
(array: WrappedArray[A]).containsSlice(that)
(array: ArrayOps[A]).corresponds(that)(p)
(array: WrappedArray[A]).corresponds(that)(p)
(array: ArrayOps[A]).count(p)
(array: WrappedArray[A]).count(p)
(array: IterableOps[A]).count(p)
(array: ArrayOps[A]).deep
(array: WrappedArray[A]).deep
(array: ArrayOps[A]).distinct
(array: WrappedArray[A]).distinct
(array: ArrayOps[A]).drop(n)
(array: WrappedArray[A]).drop(n)
(array: IterableOps[A]).drop(n)
(array: ArrayOps[A]).dropRight(n)
(array: WrappedArray[A]).dropRight(n)
(array: IterableOps[A]).dropRight(n)
(array: ArrayOps[A]).dropWhile(p)
(array: WrappedArray[A]).dropWhile(p)
(array: IterableOps[A]).dropWhile(p)
(array: ArrayOps[A]).endsWith(that)
(array: WrappedArray[A]).endsWith(that)
(array: ArrayOps[A]).equals(that)
(array: WrappedArray[A]).equals(that)
(array: ArrayOps[A]).exists(p)
(array: WrappedArray[A]).exists(p)
(array: IterableOps[A]).exists(p)
(array: ArrayOps[A]).filter(p)
(array: WrappedArray[A]).filter(p)
(array: IterableOps[A]).filter(p)
(array: ArrayOps[A]).filterNot(p)
(array: WrappedArray[A]).filterNot(p)
(array: IterableOps[A]).filterNot(p)
(array: ArrayOps[A]).find(p)
(array: WrappedArray[A]).find(p)
(array: IterableOps[A]).find(p)
(array: WrappedArray[A]).flatMap(f)(bf)
(array: IterableOps[A]).flatMap(f)(bf)
(array: WrappedArray[A]).flatten(asTraversable)
(array: IterableOps[A]).flatten(asTraversable)
(array: ArrayOps[A]).foldLeft(z)(op)
(array: WrappedArray[A]).foldLeft(z)(op)
(array: ArrayOps[A]).foldRight(z)(op)
(array: WrappedArray[A]).foldRight(z)(op)
(array: ArrayOps[A]).forall(p)
(array: WrappedArray[A]).forall(p)
(array: IterableOps[A]).forall(p)
(array: ArrayOps[A]).foreach(f)
(array: WrappedArray[A]).foreach(f)
(array: WrappedArray[A]).genericBuilder
(array: IterableOps[A]).genericBuilder
(array: ArrayOps[A]).groupBy(f)
(array: WrappedArray[A]).groupBy(f)
(array: IterableOps[A]).groupBy(f)
(array: ArrayOps[A]).grouped(size)
(array: WrappedArray[A]).grouped(size)
(array: IterableOps[A]).grouped(size)
(array: ArrayOps[A]).hasDefiniteSize
(array: WrappedArray[A]).hasDefiniteSize
(array: IterableOps[A]).hasDefiniteSize
(array: ArrayOps[A]).hashCode()
(array: WrappedArray[A]).hashCode()
(array: ArrayOps[A]).head
(array: WrappedArray[A]).head
(array: IterableOps[A]).head
(array: ArrayOps[A]).headOption
(array: WrappedArray[A]).headOption
(array: IterableOps[A]).headOption
(array: ArrayOps[A]).indexWhere(p, from)
(array: ArrayOps[A]).indexWhere(p)
(array: WrappedArray[A]).indexWhere(p, from)
(array: WrappedArray[A]).indexWhere(p)
(array: ArrayOps[A]).indices
(array: WrappedArray[A]).indices
(array: ArrayOps[A]).init
(array: WrappedArray[A]).init
(array: IterableOps[A]).init
(array: ArrayOps[A]).inits
(array: WrappedArray[A]).inits
(array: IterableOps[A]).inits
(array: ArrayOps[A]).isDefinedAt(idx)
(array: WrappedArray[A]).isDefinedAt(idx)
(array: ArrayOps[A]).isEmpty
(array: WrappedArray[A]).isEmpty
(array: IterableOps[A]).isEmpty
(array: ArrayOps[A]).isTraversableAgain
(array: WrappedArray[A]).isTraversableAgain
(array: IterableOps[A]).isTraversableAgain
(array: ArrayOps[A]).iterator
(array: WrappedArray[A]).iterator
(array: IterableOps[A]).iterator
(array: ArrayOps[A]).last
(array: WrappedArray[A]).last
(array: IterableOps[A]).last
(array: ArrayOps[A]).lastIndexWhere(p, end)
(array: ArrayOps[A]).lastIndexWhere(p)
(array: WrappedArray[A]).lastIndexWhere(p, end)
(array: WrappedArray[A]).lastIndexWhere(p)
(array: ArrayOps[A]).lastOption
(array: WrappedArray[A]).lastOption
(array: IterableOps[A]).lastOption
(array: ArrayOps[A]).length
(array: WrappedArray[A]).length
(array: ArrayOps[A]).lengthCompare(len)
(array: WrappedArray[A]).lengthCompare(len)
(array: WrappedArray[A]).map(f)(bf)
(array: IterableOps[A]).map(f)(bf)
(array: ArrayOps[A]).maxBy(f)(cmp)
(array: WrappedArray[A]).maxBy(f)(cmp)
(array: IterableOps[A]).maxBy(f)(cmp)
(array: ArrayOps[A]).minBy(f)(cmp)
(array: WrappedArray[A]).minBy(f)(cmp)
(array: IterableOps[A]).minBy(f)(cmp)
(array: ArrayOps[A]).mkString
(array: ArrayOps[A]).mkString(sep)
(array: ArrayOps[A]).mkString(start, sep, end)
(array: WrappedArray[A]).mkString
(array: WrappedArray[A]).mkString(sep)
(array: WrappedArray[A]).mkString(start, sep, end)
(array: IterableOps[A]).mkString
(array: IterableOps[A]).mkString(sep)
(array: IterableOps[A]).mkString(start, sep, end)
(array: ArrayOps[A]).nonEmpty
(array: WrappedArray[A]).nonEmpty
(array: IterableOps[A]).nonEmpty
(array: ArrayOps[A]).par
(array: WrappedArray[A]).par
(array: IterableOps[A]).par
(array: ArrayOps[A]).partition(p)
(array: WrappedArray[A]).partition(p)
(array: IterableOps[A]).partition(p)
(array: ArrayOps[A]).permutations
(array: WrappedArray[A]).permutations
(array: ArrayOps[A]).prefixLength(p)
(array: WrappedArray[A]).prefixLength(p)
(array: ArrayOps[A]).repr
(array: WrappedArray[A]).repr
(array: IterableOps[A]).repr
(array: ArrayOps[A]).result()
(array: WrappedArray[A]).result()
(array: ArrayOps[A]).reverse
(array: WrappedArray[A]).reverse
(array: ArrayOps[A]).reverseIterator
(array: WrappedArray[A]).reverseIterator
(array: WrappedArray[A]).scanLeft(z)(op)(bf)
(array: IterableOps[A]).scanLeft(z)(op)(bf)
(array: WrappedArray[A]).scanRight(z)(op)(bf)
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
(array: IterableOps[A]).scanRight(z)(op)(bf)
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
(array: ArrayOps[A]).segmentLength(p, from)
(array: WrappedArray[A]).segmentLength(p, from)
(array: StringAdd).self
(array: StringFormat).self
(array: ArrayOps[A]).seq
(array: WrappedArray[A]).seq
(array: IterableOps[A]).seq
(array: ArrayOps[A]).size
(array: WrappedArray[A]).size
(array: IterableOps[A]).size
(array: ArrayOps[A]).sizeHint(coll, delta)
(array: ArrayOps[A]).sizeHint(coll)
(array: ArrayOps[A]).sizeHint(size)
(array: WrappedArray[A]).sizeHint(coll, delta)
(array: WrappedArray[A]).sizeHint(coll)
(array: WrappedArray[A]).sizeHint(size)
(array: ArrayOps[A]).sizeHintBounded(size, boundingColl)
(array: WrappedArray[A]).sizeHintBounded(size, boundingColl)
(array: ArrayOps[A]).slice(from, until)
(array: WrappedArray[A]).slice(from, until)
(array: IterableOps[A]).slice(from, until)
(array: ArrayOps[A]).sliding(size, step)
(array: ArrayOps[A]).sliding(size)
(array: WrappedArray[A]).sliding(size, step)
(array: WrappedArray[A]).sliding(size)
(array: IterableOps[A]).sliding(size, step)
(array: IterableOps[A]).sliding(size)
(array: ArrayOps[A]).sortBy(f)(ord)
(array: WrappedArray[A]).sortBy(f)(ord)
(array: ArrayOps[A]).sortWith(lt)
(array: WrappedArray[A]).sortWith(lt)
(array: ArrayOps[A]).span(p)
(array: WrappedArray[A]).span(p)
(array: IterableOps[A]).span(p)
(array: ArrayOps[A]).splitAt(n)
(array: WrappedArray[A]).splitAt(n)
(array: IterableOps[A]).splitAt(n)
(array: ArrayOps[A]).startsWith(that, offset)
(array: ArrayOps[A]).startsWith(that)
(array: WrappedArray[A]).startsWith(that, offset)
(array: WrappedArray[A]).startsWith(that)
(array: ArrayOps[A]).stringPrefix
(array: WrappedArray[A]).stringPrefix
(array: IterableOps[A]).stringPrefix
(array: ArrayOps[A]).tail
(array: WrappedArray[A]).tail
(array: IterableOps[A]).tail
(array: ArrayOps[A]).tails
(array: WrappedArray[A]).tails
(array: IterableOps[A]).tails
(array: ArrayOps[A]).take(n)
(array: WrappedArray[A]).take(n)
(array: IterableOps[A]).take(n)
(array: ArrayOps[A]).takeRight(n)
(array: WrappedArray[A]).takeRight(n)
(array: IterableOps[A]).takeRight(n)
(array: ArrayOps[A]).takeWhile(p)
(array: WrappedArray[A]).takeWhile(p)
(array: IterableOps[A]).takeWhile(p)
(array: ArrayOps[A]).to(cbf)
(array: WrappedArray[A]).to(cbf)
(array: IterableOps[A]).to(cbf)
(array: ArrayOps[A]).toBuffer
(array: WrappedArray[A]).toBuffer
(array: IterableOps[A]).toBuffer
(array: ArrayOps[A]).toIndexedSeq
(array: WrappedArray[A]).toIndexedSeq
(array: IterableOps[A]).toIndexedSeq
(array: ArrayOps[A]).toIterable
(array: WrappedArray[A]).toIterable
(array: IterableOps[A]).toIterable
(array: ArrayOps[A]).toIterator
(array: WrappedArray[A]).toIterator
(array: IterableOps[A]).toIterator
(array: ArrayOps[A]).toList
(array: WrappedArray[A]).toList
(array: IterableOps[A]).toList
(array: ArrayOps[A]).toMap(ev)
(array: WrappedArray[A]).toMap(ev)
(array: IterableOps[A]).toMap(ev)
(array: ArrayOps[A]).toSeq
(array: WrappedArray[A]).toSeq
(array: IterableOps[A]).toSeq
(array: ArrayOps[A]).toSet
(array: WrappedArray[A]).toSet
(array: IterableOps[A]).toSet
(array: ArrayOps[A]).toStream
(array: WrappedArray[A]).toStream
(array: IterableOps[A]).toStream
(array: ArrayOps[A]).toString()
(array: WrappedArray[A]).toString()
(array: IterableOps[A]).toString()
(array: ArrayOps[A]).toTraversable
(array: WrappedArray[A]).toTraversable
(array: IterableOps[A]).toTraversable
(array: ArrayOps[A]).toVector
(array: WrappedArray[A]).toVector
(array: IterableOps[A]).toVector
(array: WrappedArray[A]).transpose(asTraversable)
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
(array: IterableOps[A]).transpose(asTraversable)
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
(array: WrappedArray[A]).unzip(asPair)
(array: IterableOps[A]).unzip(asPair)
(array: WrappedArray[A]).unzip3(asTriple)
(array: IterableOps[A]).unzip3(asTriple)
(array: ArrayOps[A]).update(index, element)
(array: WrappedArray[A]).update(index, elem)
(array: ArrayOps[A]).view(from, until)
(array: ArrayOps[A]).view
(array: WrappedArray[A]).view(from, until)
(array: WrappedArray[A]).view
(array: IterableOps[A]).view(from, until)
(array: IterableOps[A]).view
(array: ArrayOps[A]).withFilter(p)
(array: WrappedArray[A]).withFilter(p)
(array: IterableOps[A]).withFilter(p)
(Since version 2.10.0) use fold instead
(Since version 2.10.0) use fold instead
(Since version 2.10.0) use fold instead
(array: ArrowAssoc[Array[A]]).x
(Since version 2.10.0) Use leftOfArrow instead
(array: Ensuring[Array[A]]).x
(Since version 2.10.0) Use resultOfEnsuring instead
Arrays are list-like objects whose prototype has methods to perform traversal and mutation operations. Neither the length of a JavaScript array nor the types of its elements are fixed. Since an array's size length grow or shrink at any time, JavaScript arrays are not guaranteed to be dense. In general, these are convenient characteristics; but if these features are not desirable for your particular use, you might consider using typed arrays.
MDN
To construct a new array with uninitialized elements, use the constructor of this class. To construct a new array with specified elements, as if you used the array literal syntax in JavaScript, use the Array.apply method instead.
Type of the elements of the array