ceylon.language.Array.ceylon Maven / Gradle / Ivy
"A fixed-sized array of mutable elements. An _empty_ array
is an array of [[size]] `0`. An array may be created with
a list of initial elements, or, via the constructor
[[ofSize]], with a size and single initial value for all
elements.
value array = Array { \"hello\", \"world\" };
value ints = Array.ofSize(1k, 0);
Arrays are mutable. Any element of an array may be set to a
new value.
value array = Array { \"hello\", \"world\" };
array.set(0, \"goodbye\");
Arrays are lists and support all operations inherited from
[[List]], along with certain additional operations for
efficient mutation of the array: [[set]], [[swap]], [[move]],
[[sortInPlace]], [[reverseInPlace]], and [[copyTo]].
This class is provided primarily to support interoperation
with Java, and for some performance-critical low-level
programming tasks."
tagged("Collections")
shared final serializable native class Array
satisfies SearchableList &
Ranged> {
"Create an array with the given [[elements]]."
shared native new ({Element*} elements) {}
"Create an array of the specified [[size]], populating
every index with the given [[element]]. The specified
`size` must be no larger than [[runtime.maxArraySize]].
If `size<=0`, the new array will have no elements."
throws (`class AssertionError`,
"if `size>runtime.maxArraySize`")
see (`value runtime.maxArraySize`)
shared native new ofSize(
"The size of the resulting array. If the size is
non-positive, an empty array will be created."
Integer size,
"The element value with which to populate the
array. All elements of the resulting array will
have the same value."
Element element) {
assert (sizeElement? lookup(Integer index);
shared actual native Integer? lastIndex;
shared actual native Element? first;
shared actual native Element? last;
shared actual native Boolean empty;
shared actual native Integer size;
shared actual native Boolean defines(Integer index);
shared actual native Iterator iterator();
shared actual native Boolean contains(Object element);
shared actual native Element[] sequence();
shared actual native {Element&Object*} coalesced;
"A new array with the same elements as this array."
shared actual native Array clone();
"Replace the existing element at the specified [[index]]
with the given [[element]]."
throws (`class AssertionError`,
"if the given index is out of bounds, that is, if
`index<0` or if `index>lastIndex`")
shared native
void set(
"The index of the element to replace."
Integer index,
"The new element."
Element element);
"Efficiently copy the elements in the segment
`sourcePosition:length` of this array to the segment
`destinationPosition:length` of the given
[[array|destination]], which may be this array."
shared native
void copyTo(
"The array into which to copy the elements, which
may be this array."
Array destination,
"The index of the first element in this array to
copy."
Integer sourcePosition = 0,
"The index in the given array into which to copy the
first element."
Integer destinationPosition = 0,
"The number of elements to copy."
Integer length
= smallest(size - sourcePosition,
destination.size - destinationPosition));
shared actual native
Array span(Integer from, Integer to);
shared actual native
Array spanFrom(Integer from);
shared actual native
Array spanTo(Integer to);
shared actual native
Array measure(Integer from, Integer length);
shared actual native {Element*} skip(Integer skipping);
shared actual native {Element*} take(Integer taking);
shared actual native {Element*} by(Integer step);
shared actual native
Integer count(Boolean selecting(Element element));
shared actual native
void each(void step(Element element));
shared actual native
Boolean any(Boolean selecting(Element element));
shared actual native
Boolean every(Boolean selecting(Element element));
shared actual native
{Element*} filter(Boolean selecting(Element element));
shared actual native
Element? find(Boolean selecting(Element&Object element));
shared actual native
Element? findLast(Boolean selecting(Element&Object element));
shared actual native
Integer? firstIndexWhere(Boolean selecting(Element&Object element));
shared actual native
Integer? lastIndexWhere(Boolean selecting(Element&Object element));
shared actual native
{Integer*} indexesWhere(Boolean selecting(Element&Object element));
shared actual native
Element&Object>? locate(Boolean selecting(Element&Object element));
shared actual native
Element&Object>? locateLast(Boolean selecting(Element&Object element));
shared actual native
{Element&Object>*} locations(Boolean selecting(Element&Object element));
shared actual native
Result|Element|Null reduce
(Result accumulating(Result|Element partial, Element element));
shared actual native
Boolean occursAt(Integer index, Element element);
shared actual native
Integer? firstOccurrence(Element element, Integer from, Integer length);
shared actual native
Integer? lastOccurrence(Element element, Integer from, Integer length);
shared actual native
Boolean occurs(Element element, Integer from, Integer length);
shared actual native
{Integer*} occurrences(Element element, Integer from, Integer length);
"Given two indices within this array, efficiently swap
the positions of the elements at these indices. If the
two given indices are identical, no change is made to
the array. The array always contains the same elements
before and after this operation."
throws (`class AssertionError`,
"if either of the given indices is out of bounds")
shared native
void swap(
"The index of the first element."
Integer i,
"The index of the second element."
Integer j);
"Efficiently move the element of this array at the given
[[source index|from]] to the given
[[destination index|to]], shifting every element
falling between the two given indices by one position
to accommodate the change of position. If the source
index is larger than the destination index, elements
are shifted toward the end of the array. If the source
index is smaller than the destination index, elements
are shifted toward the start of the array. If the given
indices are identical, no change is made to the array.
The array always contains the same elements before and
after this operation."
throws (`class AssertionError`,
"if either of the given indices is out of bounds")
shared native
void move(
"The source index of the element to move."
Integer from,
"The destination index to which the element is
moved."
Integer to);
"Reverses the order of the current elements in this
array. This operation works by side-effect, modifying
the array. The array always contains the same elements
before and after this operation."
shared native
void reverseInPlace();
"Sorts the elements in this array according to the
order induced by the given
[[comparison function|comparing]]. This operation works
by side-effect, modifying the array. The array always
contains the same elements before and after this
operation."
shared native
void sortInPlace(
"A comparison function that compares pairs of
elements of this array."
Comparison comparing(Element x, Element y));
"Sorts the elements in this array according to the
order induced by the given
[[comparison function|comparing]], returning a new
sequence. This operation has no side-effect, and does
not modify the array."
shared actual native
Element[] sort(
"A comparison function that compares pairs of
elements of this array."
Comparison comparing(Element x, Element y));
shared actual Boolean equals(Object that)
=> (super of List).equals(that);
shared actual Integer hash
=> (super of List).hash;
shared actual String string
=> (super of Collection).string;
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy