plum

module std
import std/Byte
import std/Str
import std/Bool
import std/Number

# ByteSlice is `[]Byte` — Plum's counterpart to Go's byte slice: a
# fixed-length, mutable sequence of raw bytes backed directly by a wasm-gc
# `array<i8>` (see `plum-wasm-codegen`'s `PlumType::TByteSlice`) — the same
# raw array type `Buffer`'s own `data` field uses underneath (`Str` itself is
# now a real two-level struct wrapping a `Buffer`, not this array directly;
# see `str.plum`'s header comment). Every method here, and `makeBytes`/
# `copyBytes` below, is a compiler intrinsic (see `compileIntrinsicFnBody`)
# — there's no way to express raw array length/indexing/construction/copying
# in Plum source itself; `copyStrToBytes`/`bytesToStr` build on top of them
# instead of needing intrinsics of their own.
enum ByteSlice =
  | ByteSlice

  # Number of bytes in the slice.
  fun length(self) -> Int =
    todo

  # The raw byte at index `i`. Traps if `i` is out of range.
  fun get(self, i: Int) -> Byte =
    todo

  # Overwrites the byte at index `i` with `b`. Traps if `i` is out of range.
  fun set(self, i: Int, b: Byte) -> Unit =
    todo

# A new zero-filled `[]Byte` of length `n`.
fun makeBytes(n: Int) -> []Byte =
  todo

# Copies `n` bytes from `src` (starting at `srcStart`) into `dst` (starting at
# `dstStart`). `dst` and `src` may be the same slice — overlapping ranges are
# handled correctly, matching wasm's `array.copy`.
fun copyBytes(dst: []Byte, dstStart: Int, src: []Byte, srcStart: Int, n: Int) -> Unit =
  todo

# Like `copyBytes`, but the source is a `Str` — ordinary Plum glue over
# `copyBytes` itself, reaching through `Str`'s real `data: Buffer` field to
# its own `data: []Byte` (see `str.plum`'s header comment on `Str`'s shape).
fun copyStrToBytes(dst: []Byte, dstStart: Int, src: Str, srcStart: Int, n: Int) -> Unit =
  copyBytes(dst, dstStart, src.data.data, srcStart, n)

# Copies out `n` bytes of `src` starting at `start` into a fresh, independent
# `Str` — never aliases `src`, so mutating `src` afterwards can't
# retroactively change an already-returned `Str`. Ordinary Plum: allocate a
# right-sized `[]Byte`, copy into it, wrap it in a fresh `Buffer`/`Str` pair.
fun bytesToStr(src: []Byte, start: Int, n: Int) -> Str =
  data := makeBytes(n)
  copyBytes(data, 0, src, start, n)
  return Str(data: Buffer(data: data, len: n))