Массив[A: A]

[Source]

Непрерывный, изменяемый массив для хранения элементов типа A.

Использование

Создание массива строк:

  let array: Array[String] = ["dog"; "cat"; "wombat"]
  // array.size() == 3
  // array.space() >= 3

Создание пустого массива строк, который может содержать как минимум 10 элементов, прежде чем потребуется запрашивать больше места:

  let array = Array[String](10)
  // array.size() == 0
  // array.space() >= 10

Доступ к элементам можно получить с помощью метода apply(i: USize): this->A ?. Указанный индекс может быть вне границ, поэтому apply является частичным и должен вызываться внутри блока try-catch или внутри другого частичного метода:

  let array: Array[String] = ["dog"; "cat"; "wombat"]
  let is_second_element_wobat = try
    // indexes start from 0, so 1 is the second element
    array(1)? == "wombat"
  else
    false
  end

Добавление и удаление элементов в конец массива можно осуществить с помощью методов push и pop. Вы можете использовать массив как стек LIFO, используя эти методы:

  while (array.size() > 0) do
    let elem = array.pop()?
    // do something with element
  end

Изменение массива можно осуществить с помощью методов update, insert и delete, которые изменяют массив по произвольному индексу, перемещая элементы влево (при удалении) или вправо (при вставке), если это необходимо.

Итерацию по элементам массива можно выполнить с помощью метода values.

  for element in array.values() do
      // do something with element
  end

Выделение памяти

Массив выделяет непрерывную память. Он всегда выделяет достаточно памяти, чтобы вместить все свои элементы. Место — это количество элементов, которое массив может содержать, не выделяя дополнительной памяти. Метод space() возвращает количество элементов, которое массив может содержать. Метод size() возвращает количество элементов, которые массив содержит.

Разные типы данных требуют разного объёма памяти. Массив[U64] размером 6 займёт больше памяти, чем массив[U8] такого же размера.

При создании массива или добавлении дополнительных элементов вычисляется следующая степень двойки от запрошенного количества элементов и выделяется столько памяти, с нижней границей в 8 элементов.

Вот несколько примеров выделенной памяти при инициализации массива различным количеством элементов:

Вызовите метод compact(), чтобы попросить сборщик мусора освободить неиспользуемое пространство. Нет гарантии, что сборщик мусора фактически освободит какое-либо пространство.

class ref Array[A: A] is
  Seq[A] ref

Реализует

• Seq[A] ref

Конструкторы

create

[Source]

Создать массив с нулём элементов, но с местом для len элементов.

new ref create(
  len: USize val = 0)
: Array[A] ref^

Параметры

• len: USize val = 0

Возвращает

• Массив[A] ref^

init

[Source]

Создать массив из len элементов, все инициализированные заданным значением.

new ref init(
  from: A^,
  len: USize val)
: Array[A] ref^

Параметры

• from: A^
• len: USize val

Возвращает

• Массив[A] ref^

from_cpointer

[Source]

Создать массив из указателя и длины в стиле C. Содержимое не копируется.

new ref from_cpointer(
  ptr: Pointer[A] ref,
  len: USize val,
  alloc: USize val = 0)
: Array[A] ref^

Параметры

• ptr: Указатель[A] ref
• len: USize val
• alloc: USize val = 0

Возвращает

• Массив[A] ref^

Общедоступные функции

cpointer

[Source]

Возвращает базовый указатель в стиле C.

fun box cpointer(
  offset: USize val = 0)
: Pointer[A] tag

Параметры

• offset: USize val = 0

Возвращает

• Указатель[A] tag

размер

[Source]

Количество элементов в массиве.

fun box size()
: USize val

Возвращает

• USize val

место

[Source]

Доступное место в массиве.

fun box space()
: USize val

Возвращает

• USize val

reserve

[Source]

Зарезервировать место для len элементов, включая любые элементы, которые уже находятся в массиве. Место массива увеличивается геометрически.

fun ref reserve(
  len: USize val)
: None val

Параметры

• len: USize val

Возвращает

• None val

compact

[Source]

Попытаться удалить неиспользуемое место, сделав его доступным для сборки мусора. Запрос может быть проигнорирован.

fun ref compact()
: None val

Возвращает

• None val

undefined[необязательный B: (A & Real[B] val & (I8 val | I16 val | I32 val | I64 val | I128 val | ILong val | ISize val | U8 val | U16 val | U32 val | U64 val | U128 val | ULong val | USize val | F32 val | F64 val))]

[Source]

Изменить размер на len элементов, заполнив ранее пустые элементы случайной памятью. Это разрешено только для массива чисел.

fun ref undefined[optional B: (A & Real[B] val & (I8 val | I16 val | I32 val | 
    I64 val | I128 val | ILong val | 
    ISize val | U8 val | U16 val | 
    U32 val | U64 val | U128 val | 
    ULong val | USize val | F32 val | 
    F64 val))](
  len: USize val)
: None val

Параметры

• len: USize val

Возвращает

• None val

read_u8[необязательный B: (A & Real[B] val & U8 val)]

[Source]

Считывает U8 из смещения. Это разрешено только для массива U8.

fun box read_u8[optional B: (A & Real[B] val & U8 val)](
  offset: USize val)
: U8 val ?

Параметры

• offset: USize val

Возвращает

• U8 val ?

read_u16[необязательный B: (A & Real[B] val & U8 val)]

[Source]

Считывает U16 из смещения. Это разрешено только для массива U8.

fun box read_u16[optional B: (A & Real[B] val & U8 val)](
  offset: USize val)
: U16 val ?

Параметры

• offset: USize val

Возвращает

• U16 val ?

read_u32[необязательный B: (A & Real[B] val & U8 val)]

[Source]

Считывает U32 из смещения. Это разрешено только для массива U8.

fun box read_u32[optional B: (A & Real[B] val & U8 val)](
  offset: USize val)
: U32 val ?

Параметры

• offset: USize val

Возвращает

• U32 val ?

read_u64[необязательный B: (A & Real[B] val & U8 val)]

[Source]

Считывает U64 из смещения. Это разрешено только для массива U8.

fun box read_u64[optional B: (A & Real[B] val & U8 val)](
  offset: USize val)
: U64 val ?

Параметры

• offset: USize val

Возвращает

• U64 val ?

read_u128[необязательный B: (A & Real[B] val & U8 val)]

[Source]

Считывает U128 из смещения. Это разрешено только для массива U8.

fun box read_u128[optional B: (A & Real[B] val & U8 val)](
  offset: USize val)
: U128 val ?

Параметры

• offset: USize val

Возвращает

• U128 val ?

apply

[Source]

Получить i-й элемент, вызвав ошибку, если индекс вне границ.

fun box apply(
  i: USize val)
: this->A ?

Параметры

• i: USize val

Возвращает

• this->A ?

update_u8[необязательный B: (A & Real[B] val & U8 val)]

[Source]

Записать U8 по смещению. Это разрешено только для массива U8.

fun ref update_u8[optional B: (A & Real[B] val & U8 val)](
  offset: USize val,
  value: U8 val)
: U8 val ?

Параметры

• offset: USize val
• value: U8 val

Возвращает

• U8 val ?

update_u16[необязательный B: (A & Real[B] val & U8 val)]

[Source]

Записать U16 по смещению. Это разрешено только для массива U8.

fun ref update_u16[optional B: (A & Real[B] val & U8 val)](
  offset: USize val,
  value: U16 val)
: U16 val ?

Параметры

• offset: USize val
• value: U16 val

Возвращает

• U16 val ?

update_u32[optional B: (A & Real[B] val & U8 val)]

[Source]

Записать U32 по смещению. Это разрешено только для массива U8.

fun ref update_u32[optional B: (A & Real[B] val & U8 val)](
  offset: USize val,
  value: U32 val)
: U32 val ?

Параметры

• offset: USize val
• значение: U32 val

Возвращаемые значения

• U32 val ?

update_u64[optional B: (A & Real[B] val & U8 val)]

[Source]

Записать U64 по смещению. Это разрешено только для массива U8.

fun ref update_u64[optional B: (A & Real[B] val & U8 val)](
  offset: USize val,
  value: U64 val)
: U64 val ?

Параметры

• offset: USize val
• значение: U64 val

Возвращаемые значения

• U64 val ?

update_u128[optional B: (A & Real[B] val & U8 val)]

[Source]

Записать U128 по смещению. Это разрешено только для массива U8.

fun ref update_u128[optional B: (A & Real[B] val & U8 val)](
  offset: USize val,
  value: U128 val)
: U128 val ?

Параметры

• offset: USize val
• значение: U128 val

Возвращаемые значения

• U128 val ?

update

[Source]

Изменить i-й элемент, вызвав ошибку, если индекс вне диапазона.

fun ref update(
  i: USize val,
  value: A)
: A^ ?

Параметры

• i: USize val
• значение: A

Возвращаемые значения

• A^ ?

insert

[Source]

Вставить элемент в массив. Элементы после этого смещаются вверх на одну позицию, расширяя массив.

При вставке сразу за последним элементом, по индексу this.size(), элемент будет добавлен в конец, подобно push(), вставка по индексу 0 помещает значение в начало массива. Вставка по индексу за пределами this.size() вызовет ошибку.

let array = Array[U8](4)              // []
array.insert(0, 0xDE)?                // prepend: [0xDE]
array.insert(array.size(), 0xBE)?     // append:  [0xDE; 0xBE]
array.insert(1, 0xAD)?                // insert:  [0xDE; 0xAD; 0xBE]
array.insert(array.size() + 1, 0xEF)? // error

fun ref insert(
  i: USize val,
  value: A)
: None val ?

Параметры

• i: USize val
• значение: A

Возвращаемые значения

• None val ?

delete

[Source]

Удалить элемент из массива. Элементы после него смещаются вниз на одну позицию, уплотняя массив. Индекс за пределами массива вызывает ошибку. Удаляемый элемент возвращается.

fun ref delete(
  i: USize val)
: A^ ?

Параметры

• i: USize val

Возвращаемые значения

• A^ ?

truncate

[Source]

Усечь массив до заданной длины, удалив лишние элементы. Если массив уже меньше, чем len, ничего не делать.

fun ref truncate(
  len: USize val)
: None val

Параметры

• len: USize val

Возвращаемые значения

• None val

trim_in_place

[Source]

Усечь массив до указанной части, охватывая from до to. В отличие от slice, операция не выделяет новый массив и не копирует элементы.

fun ref trim_in_place(
  from: USize val = 0,
  to: USize val = call)
: None val

Параметры

• from: USize val = 0
• to: USize val = call

Возвращаемые значения

• None val

trim

[Source]

Возвратить общую часть этого массива, охватывающую from до to. И исходный, и новый массивы неизменяемы, так как они разделяют память. Операция не выделяет новый указатель на массив и не копирует элементы.

fun val trim(
  from: USize val = 0,
  to: USize val = call)
: Array[A] val

Параметры

• from: USize val = 0
• to: USize val = call

Возвращаемые значения

• Array[A] val

chop[optional B: (A & Any #send)]

[Source]

Разбивает массив пополам в точке разделения, запрошенной для возврата обеих частей. Исходный массив обрезается на месте и возвращается как левая часть. Если точка разделения больше, чем массив, левая часть — это исходный массив, а правая часть — новый пустой массив. Операция не выделяет новый указатель на массив и не копирует элементы.

Тип элемента должен быть отправляемым, чтобы две половины могли быть изолированы. В противном случае две записи могут иметь общие ссылки на изменяемые данные или даже на друг друга, как в коде ниже:

  class Example
     var other: (Example | None) = None

  let arr: Array[Example] iso = recover
     let obj1 = Example
     let obj2 = Example
     obj1.other = obj2
     obj2.other = obj1
     [obj1; obj2]
  end

fun iso chop[optional B: (A & Any #send)](
  split_point: USize val)
: (Array[A] iso^ , Array[A] iso^)

Параметры

• split_point: USize val

Возвращаемые значения

• (Array[A] iso^ , Array[A] iso^)

unchop

[Source]

Объединяет два изолированных массива, чтобы вернуть исходный массив, из которого они были разделены. Оба входных массива изолированы и изменяемы и изначально были разделены из одного массива. Эта функция проверяет, что это действительно два массива, разделенных из одного исходного массива, и может объединить их перед объединением и возвратом объединения. Если два массива нельзя объединить, она возвращает оба массива без изменений. Операция не выделяет новый указатель на массив и не копирует элементы.

fun iso unchop(
  b: Array[A] iso)
: ((Array[A] iso^ , Array[A] iso^) | Array[A] iso^)

Параметры

• b: Array[A] iso

Возвращаемые значения

• ((Array[A] iso^ , Array[A] iso^) | Array[A] iso^)

copy_from[optional B: (A & Real[B] val & U8 val)]

[Source]

Скопировать len элементов из src(src_idx) в this(dst_idx). Работает только для Array[U8].

fun ref copy_from[optional B: (A & Real[B] val & U8 val)](
  src: Array[U8 val] box,
  src_idx: USize val,
  dst_idx: USize val,
  len: USize val)
: None val

Параметры

• src: Array[U8 val] box
• src_idx: USize val
• dst_idx: USize val
• len: USize val

Возвращаемые значения

• None val

copy_to

[Source]

Скопировать len элементов из this(src_idx) в dst(dst_idx).

fun box copy_to(
  dst: Array[this->A!] ref,
  src_idx: USize val,
  dst_idx: USize val,
  len: USize val)
: None val

Параметры

• dst: Array[this->A!] ref
• src_idx: USize val
• dst_idx: USize val
• len: USize val

Возвращаемые значения

• None val

remove

[Source]

Удалить n элементов из массива, начиная с индекса i.

fun ref remove(
  i: USize val,
  n: USize val)
: None val

Параметры

• i: USize val
• n: USize val

Возвращаемые значения

• None val

clear

[Source]

Удалить все элементы из массива.

fun ref clear()
: None val

Возвращаемые значения

• None val

push_u8[optional B: (A & Real[B] val & U8 val)]

[Source]

Добавить U8 в конец массива. Это разрешено только для массива U8.

fun ref push_u8[optional B: (A & Real[B] val & U8 val)](
  value: U8 val)
: None val

Параметры

• значение: U8 val

Возвращаемые значения

• None val

push_u16[optional B: (A & Real[B] val & U8 val)]

[Source]

Добавить U16 в конец массива. Это разрешено только для массива U8.

fun ref push_u16[optional B: (A & Real[B] val & U8 val)](
  value: U16 val)
: None val

Параметры

• значение: U16 val

Возвращаемые значения

• None val

push_u32[optional B: (A & Real[B] val & U8 val)]

[Source]

Добавить U32 в конец массива. Это разрешено только для массива U8.

fun ref push_u32[optional B: (A & Real[B] val & U8 val)](
  value: U32 val)
: None val

Параметры

• значение: U32 val

Возвращаемые значения

• None val

push_u64[optional B: (A & Real[B] val & U8 val)]

[Source]

Добавить U64 в конец массива. Это разрешено только для массива U8.

fun ref push_u64[optional B: (A & Real[B] val & U8 val)](
  value: U64 val)
: None val

Параметры

• значение: U64 val

Возвращаемые значения

• None val

push_u128[optional B: (A & Real[B] val & U8 val)]

[Источник]

Добавить U128 в конец массива. Это разрешено только для массивов U8.

fun ref push_u128[optional B: (A & Real[B] val & U8 val)](
  value: U128 val)
: None val

Параметры

• value: U128 значение

Возвращает

• None значение

push

[Источник]

Добавить элемент в конец массива.

fun ref push(
  value: A)
: None val

Параметры

• value: A

Возвращает

• None значение

pop

[Источник]

Удалить элемент из конца массива. Удаленный элемент возвращается.

fun ref pop()
: A^ ?

Возвращает

• A^ ?

unshift

[Источник]

Добавить элемент в начало массива.

fun ref unshift(
  value: A)
: None val

Параметры

• value: A

Возвращает

• None значение

shift

[Источник]

Удалить элемент из начала массива. Удаленный элемент возвращается.

fun ref shift()
: A^ ?

Возвращает

• A^ ?

append

[Источник]

Добавить элементы из последовательности, начиная с заданного смещения.

fun ref append(
  seq: (ReadSeq[A] box & ReadElement[A^] box),
  offset: USize val = 0,
  len: USize val = call)
: None val

Параметры

• seq: (ReadSeq[A] box & ReadElement[A^] box)
• offset: USize значение = 0
• len: USize значение = вызов

Возвращает

• None значение

concat

[Источник]

Добавить len элементов итератора в конец массива, начиная с заданного смещения.

fun ref concat(
  iter: Iterator[A^] ref,
  offset: USize val = 0,
  len: USize val = call)
: None val

Параметры

• iter: Iterator[A^] ссылка
• offset: USize значение = 0
• len: USize значение = вызов

Возвращает

• None значение

find

[Источник]

Найти nth появление value с начала массива, начиная с offset, рассматривая более высокие индексы и используя предоставленный predicate для сравнений. Возвращает индекс значения или генерирует ошибку, если значение отсутствует.

По умолчанию поиск начинается с первого элемента массива, возвращает первое найденное value и использует тождество объектов для сравнения.

fun box find(
  value: A!,
  offset: USize val = 0,
  nth: USize val = 0,
  predicate: {(box->A!, box->A!): Bool}[A] val = lambda)
: USize val ?

Параметры

• value: A!
• offset: USize значение = 0
• nth: USize значение = 0
• predicate: {(box->A!, box->A!): Bool}[A] значение = лямбда

Возвращает

• USize значение ?

contains

[Источник]

Возвращает true, если массив содержит value, иначе false.

По умолчанию предикат проверяет совпадения по идентификатору. Чтобы искать совпадения по структурному равенству, передайте литерал объекта, например {(l, r) => l == r}.

fun box contains(
  value: A!,
  predicate: {(box->A!, box->A!): Bool}[A] val = lambda)
: Bool val

Параметры

• value: A!
• predicate: {(box->A!, box->A!): Bool}[A] значение = лямбда

Возвращает

• Bool значение

rfind

[Источник]

Найти nth появление value с конца массива, начиная с offset и рассматривая более низкие индексы, и используя предоставленный predicate для сравнений. Возвращает индекс значения или генерирует ошибку, если значение отсутствует.

По умолчанию поиск начинается с последнего элемента массива, возвращает первое найденное value и использует тождество объектов для сравнения.

fun box rfind(
  value: A!,
  offset: USize val = call,
  nth: USize val = 0,
  predicate: {(box->A!, box->A!): Bool}[A] val = lambda)
: USize val ?

Параметры

• value: A!
• offset: USize значение = вызов
• nth: USize значение = 0
• predicate: {(box->A!, box->A!): Bool}[A] значение = лямбда

Возвращает

• USize значение ?

clone

[Источник]

Создать копию массива. Новый массив содержит ссылки на те же элементы, что и старый массив, сами элементы не клонируются.

fun box clone()
: Array[this->A!] ref^

Возвращает

• Массив[this->A!] ссылка^

slice

[Источник]

Создать новый массив, являющийся копией части этого массива. Диапазон исключает конечные значения и насыщается. Новый массив содержит ссылки на те же элементы, что и старый массив, сами элементы не клонируются.

fun box slice(
  from: USize val = 0,
  to: USize val = call,
  step: USize val = 1)
: Array[this->A!] ref^

Параметры

• from: USize значение = 0
• to: USize значение = вызов
• step: USize значение = 1

Возвращает

• Массив[this->A!] ссылка^

permute

[Источник]

Создать новый массив с переупорядоченными элементами. Переупорядочение в произвольном порядке, который может содержать дубликаты. Индекс за пределами массива вызывает ошибку. Новый массив содержит ссылки на те же элементы, что и старый массив, сами элементы не копируются.

fun box permute(
  indices: Iterator[USize val] ref)
: Array[this->A!] ref^ ?

Параметры

• indices: Iterator[USize значение] ссылка

Возвращает

• Массив[this->A!] ссылка^ ?

reverse

[Источник]

Создать новый массив с элементами в обратном порядке. Новый массив содержит ссылки на те же элементы, что и старый массив, сами элементы не копируются.

fun box reverse()
: Array[this->A!] ref^

Возвращает

• Массив[this->A!] ссылка^

reverse_in_place

[Источник]

Перевернуть массив на месте.

fun ref reverse_in_place()
: None val

Возвращает

• None значение

swap_elements

[Источник]

Поменять элементы по индексам i и j. Если i или j находятся за пределами массива, генерируется ошибка.

fun ref swap_elements(
  i: USize val,
  j: USize val)
: None val ?

Параметры

• i: USize значение
• j: USize значение

Возвращает

• None значение ?

keys

[Источник]

Возвратить итератор по индексам в массиве.

fun box keys()
: ArrayKeys[A, this->Array[A] ref] ref^

Возвращает

• ArrayKeys[A, this->Массив[A] ссылка] ссылка^

values

[Источник]

Возвратить итератор по значениям в массиве.

fun box values()
: ArrayValues[A, this->Array[A] ref] ref^

Возвращает

• ArrayValues[A, this->Массив[A] ссылка] ссылка^

pairs

[Источник]

Возвратить итератор по парам (индекс, значение) в массиве.

fun box pairs()
: ArrayPairs[A, this->Array[A] ref] ref^

Возвращает

• ArrayPairs[A, this->Массив[A] ссылка] ссылка^