fn pub static filled[V: Clone[V]](with: V, times: Int) -> Array[V] {
  if times == 0 { return [] }

  let array = with_capacity(times)
  let temp = ref with

  (times - 1).times(fn (_) { array.push(temp.clone) })
  array.push(with)
  array
}

fn pub static with_capacity(size: Int) -> Array[T] {
  if size < 0 { panic('The capacity must be greater than or equal to zero') }

  let vsize = _INKO.size_of_type_parameter(T)
  let buffer = alloc_imp.resize(0x0 as Pointer[T], size: size * vsize)

  Array(size: 0, capacity: size, buffer: buffer)
}

fn pub !=(other: T) -> Bool {
  (self == other).false?
}

fn pub ==(other: ref Array[T]) -> Bool {
  if @size != other.size { return false }

  let mut index = 0
  let max = @size

  while index < max {
    let ours = get(index)
    let theirs = other.get(index)

    if ours != theirs { return false }

    index += 1
  }

  true
}

fn pub mut append(other: Array[T]) {
  other.into_iter.each(fn (v) { push(v) })
}

fn pub capacity -> Int {
  @capacity
}

fn pub mut clear {
  let mut index = 0
  let max = @size

  while index < max { read_from(index := index + 1) }

  @size = 0
}

fn pub clone -> Array[T] {
  let len = @size
  let copy = Array.with_capacity(len)
  let mut index = 0

  while index < len { copy.push(get(index := index + 1).clone) }

  copy
}

fn pub contains?(value: ref T) -> Bool {
  iter.any?(fn (ours) { ours == value })
}

fn pub empty? -> Bool {
  @size == 0
}

fn pub fmt(formatter: mut Formatter) {
  let fmt = formatter.array

  iter.each(fn (value) { fmt.value(value) })
  fmt.finish
}

fn pub get(index: Int) -> ref T {
  bounds_check(index, @size)
  get_unchecked(index)
}

fn pub mut get_mut(index: Int) -> mut T {
  bounds_check(index, @size)
  get_unchecked_mut(index)
}

fn pub hash[H: mut + Hasher](hasher: mut H) {
  let mut index = 0
  let max = @size

  while index < max { get(index := index + 1).hash(hasher) }
}

fn pub index_of(value: ref T) -> Option[Int] {
  let mut idx = 0

  while idx < @size {
    if get_unchecked(idx) == value { return Option.Some(idx) }

    idx += 1
  }

  Option.None
}

fn pub mut insert(index: Int, value: T) {
  if index < 0 or index > @size {
    panic('The index ${index} is out of bounds (size: ${@size})')
  }

  reserve(1)

  # Shift to the right if the insertion isn't at the end of the array. If we
  # have values like this:
  #
  #     [A, B, C, D]
  #
  # And we want to insert at the index of B (index 1), this results in the
  # following values:
  #
  #     [A, B, B, C, D]
  #
  # We can then overwrite index 1 with the value to insert.
  if index < @size {
    let from = address_of(index)
    let to = address_of(index + 1)
    let vsize = _INKO.size_of_type_parameter(T)

    alloc_imp.copy(from, to, size: @size - index * vsize)
  }

  write_to(index, value)
  @size += 1
}

fn pub move into_iter -> IntoIter[T] {
  IntoIter(array: self, index: 0)
}

fn pub iter -> Stream[ref T] {
  let mut idx = 0
  let max = @size

  Stream.new(fn move {
    if idx < max {
      Option.Some(get_unchecked(idx := idx + 1))
    } else {
      Option.None
    }
  })
}

fn pub mut iter_mut -> Stream[mut T] {
  let mut idx = 0
  let max = @size

  Stream.new(fn move {
    if idx < max {
      Option.Some(get_unchecked_mut(idx := idx + 1))
    } else {
      Option.None
    }
  })
}

fn pub last -> Option[ref T] {
  opt(size - 1)
}

fn pub mut last_mut -> Option[mut T] {
  opt_mut(size - 1)
}

fn pub opt(index: Int) -> Option[ref T] {
  if index < 0 or index >= @size { return Option.None }

  Option.Some(get_unchecked(index))
}

fn pub mut opt_mut(index: Int) -> Option[mut T] {
  if index < 0 or index >= @size { return Option.None }

  Option.Some(get_unchecked_mut(index))
}

fn pub mut pop -> Option[T] {
  if @size == 0 { return Option.None }

  @size -= 1
  Option.Some(read_from(@size))
}

fn pub mut push(value: T) {
  reserve(1)
  write_to(@size, value)
  @size += 1
}

fn pub mut remove_at(index: Int) -> T {
  let len = size

  bounds_check(index, len)

  let addr = address_of(index)
  let val = addr.0
  let vsize = _INKO.size_of_type_parameter(T)

  alloc_imp.copy(
    from: addr as Int + vsize as Pointer[T],
    to: addr,
    size: len - index - 1 * vsize,
  )

  @size = len - 1
  val
}

fn pub mut reserve(size: Int) {
  if @capacity - @size >= size { return }

  let vsize = _INKO.size_of_type_parameter(T)

  @capacity = max(@capacity * 2, @capacity + size)
  @buffer = alloc_imp.resize(@buffer, @capacity * vsize)
}

fn pub mut reverse {
  let mut a = 0
  let mut b = @size - 1

  while a < b {
    let a_val = read_from(a)
    let b_val = read_from(b)

    write_to(b, a_val)
    write_to(a, b_val)
    a += 1
    b -= 1
  }
}

fn pub reverse_iter -> Stream[ref T] {
  let mut index = size - 1

  Stream.new(fn move {
    if index > -1 {
      Option.Some(get(index := index - 1))
    } else {
      Option.None
    }
  })
}

fn pub mut set(index: Int, value: T) {
  bounds_check(index, @size)

  # This drops the old value, then writes the new value.
  read_from(index)
  write_to(index, value)
}

fn pub mut shuffle {
  Shuffle.new.sort(self)
}

fn pub size -> Int {
  @size
}

fn pub mut sort {
  stable_sort(self, fn (a, b) { a <= b })
}

fn pub mut sort_by(block: fn (ref T, ref T) -> Ordering) {
  stable_sort(self, fn (a, b) {
    match block.call(a, b) {
      case Less or Equal -> true
      case _ -> false
    }
  })
}

fn pub mut swap(index: Int, with: T) -> T {
  bounds_check(index, @size)

  let old = read_from(index)

  write_to(index, with)
  old
}

fn pub mut swap_indexes(index: Int, with: Int) {
  bounds_check(index, @size)
  bounds_check(with, @size)

  let a = read_from(index)
  let b = read_from(with)

  write_to(index, b)
  write_to(with, a)
}