fn pub get(index: Int) -> Result[Int, OutOfBounds]

fn pub pointer -> Pointer[UInt8]

fn pub size -> Int

fn pub bytes -> Iter[ref Self] {
  Iter(source: self, index: 0)
}

fn pub contains_bytes?[B: Bytes](bytes: ref B) -> Bool {
  index_of(bytes, starting_at: 0).some?
}

fn pub ends_with?[T: Bytes](suffix: ref T) -> Bool {
  ptr.ends_with?(pointer, size, suffix.pointer, suffix.size)
}

fn pub equals?[O: Bytes](other: ref O) -> Bool {
  let len = size

  len == other.size and (len == 0 or ptr.equal(pointer, other.pointer, len))
}

fn pub equals_while_ignoring_case?[O: Bytes](other: ref O) -> Bool {
  let len = size

  if len == 0 { return true }

  if len != other.size { return false }

  let lhs = pointer
  let rhs = other.pointer
  let mut idx = 0

  # Since we have to convert ASCII bytes to lowercase (when necessary) we
  # can't use a more efficient comparison and instead have to compare the data
  # byte by byte.
  while idx < len {
    let mut a = ptr.add(lhs, idx).0 as Int
    let mut b = ptr.add(rhs, idx).0 as Int

    if upper?(a) { a = to_lower(a) }

    if upper?(b) { b = to_lower(b) }

    if a != b { return false }

    idx += 1
  }

  true
}

fn pub index_of[B: Bytes](value: ref B, starting_at: Int) -> Option[Int] {
  # This is a naive string searching algorithm (see
  # https://en.wikipedia.org/wiki/String-searching_algorithm) for more details
  # on the various algorithms.
  #
  # We're using the naive algorithm because:
  #
  # 1. It's easy to implement
  # 2. It doesn't require any pre-processing
  # 3. At the time of writing there was no need for something more performant
  let find_size = value.size

  if find_size == 0 or size == 0 or find_size > size { return Option.None }

  let mut a = starting_at
  let max = size - find_size

  while a <= max {
    let mut b = 0

    while b < find_size and get(a + b) == value.get(b) { b += 1 }

    if b == find_size { return Option.Some(a) }

    a += 1
  }

  Option.None
}

fn pub starts_with?[T: Bytes](prefix: ref T) -> Bool {
  ptr.starts_with?(pointer, size, prefix.pointer, prefix.size)
}