builtin.mbti

package "moonbitlang/core/builtin"

// Values
fn abort[T](String) -> T

fn assert_eq[T : Eq + Show](T, T, loc~ : SourceLoc = _) -> Unit!

fn assert_false(Bool, loc~ : SourceLoc = _) -> Unit!

fn assert_not_eq[T : Eq + Show](T, T, loc~ : SourceLoc = _) -> Unit!

fn assert_true(Bool, loc~ : SourceLoc = _) -> Unit!

#deprecated
fn dump[T](T, name? : String, loc~ : SourceLoc = _) -> T

fn fail[T](String, loc~ : SourceLoc = _) -> T!Failure

fn ignore[T](T) -> Unit

fn inspect(&Show, content~ : String = .., loc~ : SourceLoc = _, args_loc~ : ArgsLoc = _) -> Unit!InspectError

fn not(Bool) -> Bool

fn op_ge[T : Compare](T, T) -> Bool

fn op_gt[T : Compare](T, T) -> Bool

fn op_le[T : Compare](T, T) -> Bool

fn op_lt[T : Compare](T, T) -> Bool

fn op_notequal[T : Eq](T, T) -> Bool

fn panic[T]() -> T

fn physical_equal[T](T, T) -> Bool

fn println[T : Show](T) -> Unit

fn repr[T : Show](T) -> String

// Types and methods
pub(all) type ArgsLoc Array[SourceLoc?]
impl ArgsLoc {
  to_json(Self) -> String
}
impl Show for ArgsLoc

type Array[T]
impl Array {
  append[T](Self[T], Self[T]) -> Unit
  binary_search[T : Compare](Self[T], T) -> Result[Int, Int]
  binary_search_by[T](Self[T], (T) -> Int) -> Result[Int, Int]
  blit_to[A](Self[A], Self[A], len~ : Int, src_offset~ : Int = .., dst_offset~ : Int = ..) -> Unit
  capacity[T](Self[T]) -> Int
  chunk_by[T](Self[T], (T, T) -> Bool) -> Self[Self[T]]
  chunks[T](Self[T], Int) -> Self[Self[T]]
  clear[T](Self[T]) -> Unit
  contains[T : Eq](Self[T], T) -> Bool
  dedup[T : Eq](Self[T]) -> Unit
  drain[T](Self[T], Int, Int) -> Self[T]
  each[T](Self[T], (T) -> Unit) -> Unit
  eachi[T](Self[T], (Int, T) -> Unit) -> Unit
  ends_with[T : Eq](Self[T], Self[T]) -> Bool
  extract_if[T](Self[T], (T) -> Bool) -> Self[T]
  filter[T](Self[T], (T) -> Bool) -> Self[T]
  #deprecated
  find_index[T](Self[T], (T) -> Bool) -> Int?
  flatten[T](Self[Self[T]]) -> Self[T]
  fold[A, B](Self[A], init~ : B, (B, A) -> B) -> B
  #deprecated
  fold_left[T, U](Self[T], (U, T) -> U, init~ : U) -> U
  #deprecated
  fold_lefti[T, U](Self[T], (Int, U, T) -> U, init~ : U) -> U
  #deprecated
  fold_right[T, U](Self[T], (U, T) -> U, init~ : U) -> U
  #deprecated
  fold_righti[T, U](Self[T], (Int, U, T) -> U, init~ : U) -> U
  foldi[A, B](Self[A], init~ : B, (Int, B, A) -> B) -> B
  from_fixed_array[T](FixedArray[T]) -> Self[T]
  get[T](Self[T], Int) -> T?
  insert[T](Self[T], Int, T) -> Unit
  is_empty[T](Self[T]) -> Bool
  is_sorted[T : Compare](Self[T]) -> Bool
  iter[T](Self[T]) -> Iter[T]
  iter2[A](Self[A]) -> Iter2[Int, A]
  length[T](Self[T]) -> Int
  make[T](Int, T) -> Self[T]
  map[T, U](Self[T], (T) -> U) -> Self[U]
  map_inplace[T](Self[T], (T) -> T) -> Unit
  mapi[T, U](Self[T], (Int, T) -> U) -> Self[U]
  mapi_inplace[T](Self[T], (Int, T) -> T) -> Unit
  new[T](capacity~ : Int = ..) -> Self[T]
  op_as_view[T](Self[T], start~ : Int = .., end? : Int) -> ArrayView[T]
  op_get[T](Self[T], Int) -> T
  op_set[T](Self[T], Int, T) -> Unit
  pop[T](Self[T]) -> T?
  #deprecated
  pop_exn[T](Self[T]) -> T
  push[T](Self[T], T) -> Unit
  remove[T](Self[T], Int) -> T
  repeat[T](Self[T], Int) -> Self[T]
  reserve_capacity[T](Self[T], Int) -> Unit
  resize[T](Self[T], Int, T) -> Unit
  retain[T](Self[T], (T) -> Bool) -> Unit
  rev[T](Self[T]) -> Self[T]
  rev_each[T](Self[T], (T) -> Unit) -> Unit
  rev_eachi[T](Self[T], (Int, T) -> Unit) -> Unit
  rev_fold[A, B](Self[A], init~ : B, (B, A) -> B) -> B
  rev_foldi[A, B](Self[A], init~ : B, (Int, B, A) -> B) -> B
  rev_inplace[T](Self[T]) -> Unit
  rev_iter[T](Self[T]) -> Iter[T]
  search[T : Eq](Self[T], T) -> Int?
  search_by[T](Self[T], (T) -> Bool) -> Int?
  shrink_to_fit[T](Self[T]) -> Unit
  split[T](Self[T], (T) -> Bool) -> Self[Self[T]]
  split_at[T](Self[T], Int) -> (Self[T], Self[T])
  starts_with[T : Eq](Self[T], Self[T]) -> Bool
  strip_prefix[T : Eq](Self[T], Self[T]) -> Self[T]?
  strip_suffix[T : Eq](Self[T], Self[T]) -> Self[T]?
  swap[T](Self[T], Int, Int) -> Unit
  unsafe_blit[A](Self[A], Int, Self[A], Int, Int) -> Unit
  unsafe_blit_fixed[A](Self[A], Int, FixedArray[A], Int, Int) -> Unit
  unsafe_get[T](Self[T], Int) -> T
  unsafe_pop[T](Self[T]) -> T
}
impl[T] Add for Array[T]
impl[T : Compare] Compare for Array[T]
impl[T] Default for Array[T]
impl[T : Eq] Eq for Array[T]
impl[X : Show] Show for Array[X]
impl[X : ToJson] ToJson for Array[X]

type ArrayView[T] //deprecated
impl ArrayView {
  length[T](Self[T]) -> Int
  op_as_view[T](Self[T], start~ : Int = .., end? : Int) -> Self[T]
  op_get[T](Self[T], Int) -> T
  op_set[T](Self[T], Int, T) -> Unit
  swap[T](Self[T], Int, Int) -> Unit
  unsafe_get[T](Self[T], Int) -> T
}
impl[X : ToJson] ToJson for ArrayView[X]

type BigInt
impl BigInt {
  #deprecated
  asr(Self, Int) -> Self
  from_hex(String) -> Self
  from_int(Int) -> Self
  from_int64(Int64) -> Self
  from_octets(Bytes, signum~ : Int = ..) -> Self
  from_string(String) -> Self
  from_uint(UInt) -> Self
  from_uint64(UInt64) -> Self
  is_zero(Self) -> Bool
  #deprecated
  lsl(Self, Int) -> Self
  pow(Self, Self, modulus? : Self) -> Self
  #deprecated
  shl(Self, Int) -> Self
  #deprecated
  shr(Self, Int) -> Self
  to_hex(Self, uppercase~ : Bool = ..) -> String
  to_int(Self) -> Int
  to_int64(Self) -> Int64
  to_octets(Self, length? : Int) -> Bytes
  to_string(Self) -> String
  to_uint(Self) -> UInt
  to_uint64(Self) -> UInt64
}
impl Add for BigInt
impl BitAnd for BigInt
impl BitOr for BigInt
impl BitXOr for BigInt
impl Compare for BigInt
impl Div for BigInt
impl Eq for BigInt
impl Mod for BigInt
impl Mul for BigInt
impl Neg for BigInt
impl Shl for BigInt
impl Show for BigInt
impl Shr for BigInt
impl Sub for BigInt
impl ToJson for BigInt

pub(all) type! Failure String
impl Show for Failure

type Hasher
impl Hasher {
  combine[T : Hash](Self, T) -> Unit
  combine_bool(Self, Bool) -> Unit
  combine_byte(Self, Byte) -> Unit
  combine_bytes(Self, Bytes) -> Unit
  combine_char(Self, Char) -> Unit
  combine_double(Self, Double) -> Unit
  combine_float(Self, Float) -> Unit
  combine_int(Self, Int) -> Unit
  combine_int64(Self, Int64) -> Unit
  combine_string(Self, String) -> Unit
  combine_uint(Self, UInt) -> Unit
  combine_uint64(Self, UInt64) -> Unit
  combine_unit(Self) -> Unit
  finalize(Self) -> Int
  new(seed~ : Int = ..) -> Self
}

pub(all) type! InspectError String

type Iter[T]
impl Iter {
  all[T](Self[T], (T) -> Bool) -> Bool
  any[T](Self[T], (T) -> Bool) -> Bool
  append[T](Self[T], T) -> Self[T]
  collect[T](Self[T]) -> Array[T]
  concat[T](Self[T], Self[T]) -> Self[T]
  contains[A : Eq](Self[A], A) -> Bool
  count[T](Self[T]) -> Int
  drop[T](Self[T], Int) -> Self[T]
  drop_while[T](Self[T], (T) -> Bool) -> Self[T]
  each[T](Self[T], (T) -> Unit) -> Unit
  eachi[T](Self[T], (Int, T) -> Unit) -> Unit
  empty[T]() -> Self[T]
  filter[T](Self[T], (T) -> Bool) -> Self[T]
  filter_map[A, B](Self[A], (A) -> B?) -> Self[B]
  find_first[T](Self[T], (T) -> Bool) -> T?
  flat_map[T, R](Self[T], (T) -> Self[R]) -> Self[R]
  flatten[T](Self[Self[T]]) -> Self[T]
  fold[T, B](Self[T], init~ : B, (B, T) -> B) -> B
  head[A](Self[A]) -> A?
  intersperse[A](Self[A], A) -> Self[A]
  iter[T](Self[T]) -> Self[T]
  join(Self[String], String) -> String
  just_run[T](Self[T], (T) -> IterResult) -> Unit
  last[A](Self[A]) -> A?
  map[T, R](Self[T], (T) -> R) -> Self[R]
  #deprecated
  map_option[A, B](Self[A], (A) -> B?) -> Self[B]
  map_while[A, B](Self[A], (A) -> B?) -> Self[B]
  maximum[T : Compare](Self[T]) -> T?
  minimum[T : Compare](Self[T]) -> T?
  new[T](((T) -> IterResult) -> IterResult) -> Self[T]
  nth[T](Self[T], Int) -> T?
  op_as_view[A](Self[A], start~ : Int = .., end? : Int) -> Self[A]
  peek[T](Self[T]) -> T?
  prepend[T](Self[T], T) -> Self[T]
  repeat[T](T) -> Self[T]
  run[T](Self[T], (T) -> IterResult) -> IterResult
  singleton[T](T) -> Self[T]
  take[T](Self[T], Int) -> Self[T]
  take_while[T](Self[T], (T) -> Bool) -> Self[T]
  tap[T](Self[T], (T) -> Unit) -> Self[T]
  to_array[T](Self[T]) -> Array[T]
}
impl[T] Add for Iter[T]
impl[T : Show] Show for Iter[T]

type Iter2[A, B]
impl Iter2 {
  concat[A, B](Self[A, B], Self[A, B]) -> Self[A, B]
  each[A, B](Self[A, B], (A, B) -> Unit) -> Unit
  iter[A, B](Self[A, B]) -> Iter[(A, B)]
  iter2[A, B](Self[A, B]) -> Self[A, B]
  new[A, B](((A, B) -> IterResult) -> IterResult) -> Self[A, B]
  run[A, B](Self[A, B], (A, B) -> IterResult) -> IterResult
  to_array[A, B](Self[A, B]) -> Array[(A, B)]
}
impl[A : Show, B : Show] Show for Iter2[A, B]

pub(all) enum IterResult {
  IterEnd
  IterContinue
}
impl Eq for IterResult

pub(all) enum Json {
  Null
  True
  False
  Number(Double)
  String(String)
  Array(Array[Json])
  Object(Map[String, Json])
}
impl Json {
  array(Array[Self]) -> Self
  boolean(Bool) -> Self
  null() -> Self
  number(Double) -> Self
  object(Map[String, Self]) -> Self
  string(String) -> Self
}
impl Default for Json
impl Eq for Json

type Map[K, V]
impl Map {
  capacity[K, V](Self[K, V]) -> Int
  clear[K, V](Self[K, V]) -> Unit
  contains[K : Hash + Eq, V](Self[K, V], K) -> Bool
  each[K, V](Self[K, V], (K, V) -> Unit) -> Unit
  eachi[K, V](Self[K, V], (Int, K, V) -> Unit) -> Unit
  from_array[K : Hash + Eq, V](Array[(K, V)]) -> Self[K, V]
  from_iter[K : Hash + Eq, V](Iter[(K, V)]) -> Self[K, V]
  get[K : Hash + Eq, V](Self[K, V], K) -> V?
  get_or_default[K : Hash + Eq, V](Self[K, V], K, V) -> V
  get_or_init[K : Hash + Eq, V](Self[K, V], K, () -> V) -> V
  is_empty[K, V](Self[K, V]) -> Bool
  iter[K, V](Self[K, V]) -> Iter[(K, V)]
  iter2[K, V](Self[K, V]) -> Iter2[K, V]
  keys[K, V](Self[K, V]) -> Iter[K]
  new[K, V](capacity~ : Int = ..) -> Self[K, V]
  of[K : Hash + Eq, V](FixedArray[(K, V)]) -> Self[K, V]
  op_get[K : Hash + Eq, V](Self[K, V], K) -> V?
  op_set[K : Hash + Eq, V](Self[K, V], K, V) -> Unit
  remove[K : Hash + Eq, V](Self[K, V], K) -> Unit
  set[K : Hash + Eq, V](Self[K, V], K, V) -> Unit
  size[K, V](Self[K, V]) -> Int
  to_array[K, V](Self[K, V]) -> Array[(K, V)]
  values[K, V](Self[K, V]) -> Iter[V]
}
impl[K, V] Default for Map[K, V]
impl[K : Hash + Eq, V : Eq] Eq for Map[K, V]
impl[K : Show, V : Show] Show for Map[K, V]
impl[K : Show, V : ToJson] ToJson for Map[K, V]

type Set[K]
impl Set {
  add[K : Hash + Eq](Self[K], K) -> Unit
  add_and_check[K : Hash + Eq](Self[K], K) -> Bool
  capacity[K](Self[K]) -> Int
  clear[K](Self[K]) -> Unit
  contains[K : Hash + Eq](Self[K], K) -> Bool
  difference[K : Hash + Eq](Self[K], Self[K]) -> Self[K]
  each[K](Self[K], (K) -> Unit) -> Unit
  eachi[K](Self[K], (Int, K) -> Unit) -> Unit
  from_array[K : Hash + Eq](Array[K]) -> Self[K]
  from_iter[K : Hash + Eq](Iter[K]) -> Self[K]
  #deprecated
  insert[K : Hash + Eq](Self[K], K) -> Unit
  intersection[K : Hash + Eq](Self[K], Self[K]) -> Self[K]
  is_empty[K](Self[K]) -> Bool
  iter[K](Self[K]) -> Iter[K]
  new[K](capacity~ : Int = ..) -> Self[K]
  of[K : Hash + Eq](FixedArray[K]) -> Self[K]
  remove[K : Hash + Eq](Self[K], K) -> Unit
  remove_and_check[K : Hash + Eq](Self[K], K) -> Bool
  size[K](Self[K]) -> Int
  symmetric_difference[K : Hash + Eq](Self[K], Self[K]) -> Self[K]
  to_array[K](Self[K]) -> Array[K]
  union[K : Hash + Eq](Self[K], Self[K]) -> Self[K]
}
impl[K : Hash + Eq] Eq for Set[K]
impl[K : Show] Show for Set[K]
impl[X : ToJson] ToJson for Set[X]

pub(all) type! SnapshotError String

pub(all) extern type SourceLoc
impl SourceLoc {
  to_string(Self) -> String
}
impl Show for SourceLoc

type StringBuilder
impl StringBuilder {
  is_empty(Self) -> Bool
  new(size_hint~ : Int = ..) -> Self
  reset(Self) -> Unit
  to_string(Self) -> String
  write_iter(Self, Iter[Char]) -> Unit
  write_object[T : Show](Self, T) -> Unit
}
impl Logger for StringBuilder
impl Show for StringBuilder

type UninitializedArray[T]
impl UninitializedArray {
  length[A](Self[A]) -> Int
  make[T](Int) -> Self[T]
  op_as_view[T](Self[T], start~ : Int = .., end? : Int) -> ArrayView[T]
  op_get[T](Self[T], Int) -> T
  op_set[T](Self[T], Int, T) -> Unit
}

impl Bool {
  #deprecated
  op_compare(Bool, Bool) -> Int
}

impl Byte {
  lnot(Byte) -> Byte
  #deprecated
  lsl(Byte, Int) -> Byte
  #deprecated
  lsr(Byte, Int) -> Byte
  to_double(Byte) -> Double
  to_float(Byte) -> Float
  to_int(Byte) -> Int
  to_int16(Byte) -> Int16
  to_int64(Byte) -> Int64
  to_string(Byte) -> String
  to_uint(Byte) -> UInt
  to_uint16(Byte) -> UInt16
}

impl Char {
  from_int(Int) -> Char
  #deprecated
  op_sub(Char, Char) -> Int
  to_int(Char) -> Int
  to_uint(Char) -> UInt
}

impl Int {
  #deprecated
  asr(Int, Int) -> Int
  clz(Int) -> Int
  ctz(Int) -> Int
  is_neg(Int) -> Bool
  is_non_neg(Int) -> Bool
  is_non_pos(Int) -> Bool
  is_pos(Int) -> Bool
  land(Int, Int) -> Int
  lnot(Int) -> Int
  lor(Int, Int) -> Int
  #deprecated
  lsl(Int, Int) -> Int
  #deprecated
  lsr(Int, Int) -> Int
  lxor(Int, Int) -> Int
  popcnt(Int) -> Int
  reinterpret_as_float(Int) -> Float
  reinterpret_as_uint(Int) -> UInt
  #deprecated
  shl(Int, Int) -> Int
  #deprecated
  shr(Int, Int) -> Int
  to_byte(Int) -> Byte
  to_double(Int) -> Double
  to_float(Int) -> Float
  to_int16(Int) -> Int16
  to_int64(Int) -> Int64
  to_string(Int, radix~ : Int = ..) -> String
  #deprecated
  to_uint(Int) -> UInt
  to_uint16(Int) -> UInt16
  to_uint64(Int) -> UInt64
  until(Int, Int, step~ : Int = .., inclusive~ : Bool = ..) -> Iter[Int]
  #deprecated
  upto(Int, Int, inclusive~ : Bool = ..) -> Iter[Int]
}

impl Int16 {
  to_byte(Int16) -> Byte
  to_int(Int16) -> Int
  to_int64(Int16) -> Int64
  to_string(Int16, radix~ : Int = ..) -> String
}

impl Int64 {
  #deprecated
  asr(Int64, Int) -> Int64
  clz(Int64) -> Int
  ctz(Int64) -> Int
  lnot(Int64) -> Int64
  #deprecated
  lsl(Int64, Int) -> Int64
  #deprecated
  lsr(Int64, Int) -> Int64
  popcnt(Int64) -> Int
  reinterpret_as_double(Int64) -> Double
  reinterpret_as_uint64(Int64) -> UInt64
  #deprecated
  shl(Int64, Int) -> Int64
  #deprecated
  shr(Int64, Int) -> Int64
  to_byte(Int64) -> Byte
  to_double(Int64) -> Double
  to_float(Int64) -> Float
  to_int(Int64) -> Int
  to_int16(Int64) -> Int16
  to_string(Int64, radix~ : Int = ..) -> String
  to_uint16(Int64) -> UInt16
  #deprecated
  to_uint64(Int64) -> UInt64
  until(Int64, Int64, step~ : Int64 = .., inclusive~ : Bool = ..) -> Iter[Int64]
  #deprecated
  upto(Int64, Int64, inclusive~ : Bool = ..) -> Iter[Int64]
}

impl UInt {
  clz(UInt) -> Int
  ctz(UInt) -> Int
  land(UInt, UInt) -> UInt
  lnot(UInt) -> UInt
  lor(UInt, UInt) -> UInt
  #deprecated
  lsl(UInt, Int) -> UInt
  #deprecated
  lsr(UInt, Int) -> UInt
  lxor(UInt, UInt) -> UInt
  op_neq(UInt, UInt) -> Bool
  popcnt(UInt) -> Int
  reinterpret_as_float(UInt) -> Float
  reinterpret_as_int(UInt) -> Int
  #deprecated
  shl(UInt, Int) -> UInt
  #deprecated
  shr(UInt, Int) -> UInt
  to_byte(UInt) -> Byte
  to_double(UInt) -> Double
  to_float(UInt) -> Float
  #deprecated
  to_int(UInt) -> Int
  to_string(UInt, radix~ : Int = ..) -> String
  to_uint64(UInt) -> UInt64
  trunc_double(Double) -> UInt
  #deprecated
  upto(UInt, UInt, inclusive~ : Bool = ..) -> Iter[UInt]
}

impl UInt16 {
  to_byte(UInt16) -> Byte
  to_int(UInt16) -> Int
  to_int64(UInt16) -> Int64
  to_string(UInt16, radix~ : Int = ..) -> String
}

impl UInt64 {
  clz(UInt64) -> Int
  ctz(UInt64) -> Int
  extend_uint(UInt) -> UInt64
  lnot(UInt64) -> UInt64
  #deprecated
  lsl(UInt64, Int) -> UInt64
  #deprecated
  lsr(UInt64, Int) -> UInt64
  popcnt(UInt64) -> Int
  reinterpret_as_double(UInt64) -> Double
  reinterpret_as_int64(UInt64) -> Int64
  #deprecated
  shl(UInt64, Int) -> UInt64
  #deprecated
  shr(UInt64, Int) -> UInt64
  to_byte(UInt64) -> Byte
  to_double(UInt64) -> Double
  to_float(UInt64) -> Float
  to_int(UInt64) -> Int
  #deprecated
  to_int64(UInt64) -> Int64
  to_string(UInt64, radix~ : Int = ..) -> String
  to_uint(UInt64) -> UInt
  trunc_double(Double) -> UInt64
  #deprecated
  upto(UInt64, UInt64, inclusive~ : Bool = ..) -> Iter[UInt64]
}

impl Float {
  op_neq(Float, Float) -> Bool
  reinterpret_as_int(Float) -> Int
  reinterpret_as_uint(Float) -> UInt
  sqrt(Float) -> Float
  to_double(Float) -> Double
  until(Float, Float, step~ : Float = .., inclusive~ : Bool = ..) -> Iter[Float]
  #deprecated
  upto(Float, Float, inclusive~ : Bool = ..) -> Iter[Float]
}

impl Double {
  convert_uint(UInt) -> Double
  convert_uint64(UInt64) -> Double
  op_neq(Double, Double) -> Bool
  #deprecated
  reinterpret_as_i64(Double) -> Int64
  reinterpret_as_int64(Double) -> Int64
  #deprecated
  reinterpret_as_u64(Double) -> UInt64
  reinterpret_as_uint64(Double) -> UInt64
  sqrt(Double) -> Double
  to_float(Double) -> Float
  to_int(Double) -> Int
  to_int64(Double) -> Int64
  to_uint64(Double) -> UInt64
  until(Double, Double, step~ : Double = .., inclusive~ : Bool = ..) -> Iter[Double]
  #deprecated
  upto(Double, Double, inclusive~ : Bool = ..) -> Iter[Double]
}

impl String {
  char_length(String, start_offset~ : Int = .., end_offset~ : Int = ..) -> Int
  charcode_at(String, Int) -> Int
  #deprecated
  charcode_length(String) -> Int
  #deprecated
  codepoint_at(String, Int) -> Char
  #deprecated
  codepoint_length(String, start_offset~ : Int = .., end_offset~ : Int = ..) -> Int
  escape(String) -> String
  #deprecated
  get(String, Int) -> Char
  length(String) -> Int
  make(Int, Char) -> String
  op_get(String, Int) -> Char
  substring(String, start~ : Int = .., end? : Int) -> String
  to_string(String) -> String
  unsafe_char_at(String, Int) -> Char
  unsafe_charcode_at(String, Int) -> Int
}

impl Option {
  to_string[X : Show](X?) -> String
  unwrap[X](X?) -> X
}

impl FixedArray {
  blit_from_bytes(Self[Byte], Int, Bytes, Int, Int) -> Unit
  blit_from_string(Self[Byte], Int, String, Int, Int) -> Unit
  blit_to[A](Self[A], Self[A], len~ : Int, src_offset~ : Int = .., dst_offset~ : Int = ..) -> Unit
  fill[T](Self[T], T) -> Unit
  get[T](Self[T], Int) -> T
  is_empty[T](Self[T]) -> Bool
  iter[T](Self[T]) -> Iter[T]
  iter2[T](Self[T]) -> Iter2[Int, T]
  length[T](Self[T]) -> Int
  make[T](Int, T) -> Self[T]
  op_get[T](Self[T], Int) -> T
  op_set[T](Self[T], Int, T) -> Unit
  set[T](Self[T], Int, T) -> Unit
  set_utf16be_char(Self[Byte], Int, Char) -> Int
  set_utf16le_char(Self[Byte], Int, Char) -> Int
  set_utf8_char(Self[Byte], Int, Char) -> Int
  unsafe_blit[A](Self[A], Int, Self[A], Int, Int) -> Unit
  unsafe_get[T](Self[T], Int) -> T
}

impl Bytes {
  copy(Bytes) -> Bytes
  length(Bytes) -> Int
  make(Int, Byte) -> Bytes
  makei(Int, (Int) -> Byte) -> Bytes
  new(Int) -> Bytes
  of_string(String) -> Bytes
  op_get(Bytes, Int) -> Byte
  to_unchecked_string(Bytes, offset~ : Int = .., length~ : Int = ..) -> String
  unsafe_get(Bytes, Int) -> Byte
}

impl Logger {
  write_iter[T : Show](&Self, Iter[T], prefix~ : String = .., suffix~ : String = .., sep~ : String = .., trailing~ : Bool = ..) -> Unit
  write_object[Obj : Show](&Self, Obj) -> Unit
}

// Type aliases

// Traits
pub(open) trait Add {
  op_add(Self, Self) -> Self
}
impl Add for Byte
impl Add for Int
impl Add for Int64
impl Add for UInt
impl Add for UInt64
impl Add for Float
impl Add for Double
impl Add for String

pub(open) trait BitAnd {
  land(Self, Self) -> Self
}
impl BitAnd for Byte
impl BitAnd for Int64
impl BitAnd for UInt64

pub(open) trait BitOr {
  lor(Self, Self) -> Self
}
impl BitOr for Byte
impl BitOr for Int64
impl BitOr for UInt64

pub(open) trait BitXOr {
  lxor(Self, Self) -> Self
}
impl BitXOr for Byte
impl BitXOr for Int64
impl BitXOr for UInt64

pub(open) trait Compare : Eq {
  compare(Self, Self) -> Int
}
impl Compare for Bool
impl Compare for Byte
impl Compare for Char
impl Compare for Int
impl Compare for Int64
impl Compare for UInt
impl Compare for UInt64
impl Compare for Float
impl Compare for Double
impl Compare for Bytes
impl[T0 : Compare, T1 : Compare] Compare for (T0, T1)
impl[T0 : Compare, T1 : Compare, T2 : Compare] Compare for (T0, T1, T2)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare] Compare for (T0, T1, T2, T3)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare] Compare for (T0, T1, T2, T3, T4)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare] Compare for (T0, T1, T2, T3, T4, T5)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare, T11 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare, T11 : Compare, T12 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare, T11 : Compare, T12 : Compare, T13 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare, T11 : Compare, T12 : Compare, T13 : Compare, T14 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
impl[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare, T11 : Compare, T12 : Compare, T13 : Compare, T14 : Compare, T15 : Compare] Compare for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

pub(open) trait Default {
  default() -> Self
}
impl Default for Bool
impl Default for Byte
impl Default for Char
impl Default for Int
impl Default for Int64
impl Default for UInt64
impl Default for Double
impl[X] Default for FixedArray[X]

pub(open) trait Div {
  op_div(Self, Self) -> Self
}
impl Div for Byte
impl Div for Int
impl Div for Int64
impl Div for UInt
impl Div for UInt64
impl Div for Float
impl Div for Double

pub(open) trait Eq {
  op_equal(Self, Self) -> Bool
}
impl Eq for Unit
impl Eq for Bool
impl Eq for Byte
impl Eq for Char
impl Eq for Int
impl Eq for Int64
impl Eq for UInt
impl Eq for UInt64
impl Eq for Float
impl Eq for Double
impl Eq for String
impl[X : Eq] Eq for X?
impl[T : Eq, E : Eq] Eq for Result[T, E]
impl Eq for Bytes
impl[T0 : Eq, T1 : Eq] Eq for (T0, T1)
impl[T0 : Eq, T1 : Eq, T2 : Eq] Eq for (T0, T1, T2)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq] Eq for (T0, T1, T2, T3)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq] Eq for (T0, T1, T2, T3, T4)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq] Eq for (T0, T1, T2, T3, T4, T5)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq, T11 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq, T11 : Eq, T12 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq, T11 : Eq, T12 : Eq, T13 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq, T11 : Eq, T12 : Eq, T13 : Eq, T14 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
impl[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq, T11 : Eq, T12 : Eq, T13 : Eq, T14 : Eq, T15 : Eq] Eq for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

pub(open) trait Hash {
  hash_combine(Self, Hasher) -> Unit
  hash(Self) -> Int
}
impl Hash::hash
impl Hash for Byte
impl Hash for Int
impl Hash for UInt
impl Hash for UInt64
impl Hash for String
impl[X : Hash] Hash for X?
impl[T : Hash, E : Hash] Hash for Result[T, E]
impl[A : Hash, B : Hash] Hash for (A, B)
impl[A : Hash, B : Hash, C : Hash] Hash for (A, B, C)
impl[A : Hash, B : Hash, C : Hash, D : Hash] Hash for (A, B, C, D)
impl[A : Hash, B : Hash, C : Hash, D : Hash, E : Hash] Hash for (A, B, C, D, E)
impl[A : Hash, B : Hash, C : Hash, D : Hash, E : Hash, F : Hash] Hash for (A, B, C, D, E, F)
impl[A : Hash, B : Hash, C : Hash, D : Hash, E : Hash, F : Hash, G : Hash] Hash for (A, B, C, D, E, F, G)

pub(open) trait Logger {
  write_string(Self, String) -> Unit
  write_substring(Self, String, Int, Int) -> Unit
  write_char(Self, Char) -> Unit
}
impl Logger::write_char

pub(open) trait Mod {
  op_mod(Self, Self) -> Self
}
impl Mod for Int
impl Mod for Int64
impl Mod for UInt
impl Mod for UInt64

pub(open) trait Mul {
  op_mul(Self, Self) -> Self
}
impl Mul for Byte
impl Mul for Int
impl Mul for Int64
impl Mul for UInt
impl Mul for UInt64
impl Mul for Float
impl Mul for Double

pub(open) trait Neg {
  op_neg(Self) -> Self
}
impl Neg for Int
impl Neg for Int64
impl Neg for Float
impl Neg for Double

pub(open) trait Shl {
  op_shl(Self, Int) -> Self
}
impl Shl for Byte
impl Shl for Int
impl Shl for Int64
impl Shl for UInt
impl Shl for UInt64

pub(open) trait Show {
  output(Self, &Logger) -> Unit
  to_string(Self) -> String
}
impl Show::to_string
impl Show for Unit
impl Show for Bool
impl Show for Byte
impl Show for Char
impl Show for Int
impl Show for Int16
impl Show for Int64
impl Show for UInt
impl Show for UInt16
impl Show for UInt64
impl Show for String
impl[X : Show] Show for X?
impl[T : Show, E : Show] Show for Result[T, E]
impl[X : Show] Show for FixedArray[X]
impl Show for Bytes
impl[X : Show] Show for Ref[X]
impl[A : Show, B : Show] Show for (A, B)
impl[A : Show, B : Show, C : Show] Show for (A, B, C)
impl[A : Show, B : Show, C : Show, D : Show] Show for (A, B, C, D)
impl[A : Show, B : Show, C : Show, D : Show, E : Show] Show for (A, B, C, D, E)
impl[A : Show, B : Show, C : Show, D : Show, E : Show, F : Show] Show for (A, B, C, D, E, F)
impl[A : Show, B : Show, C : Show, D : Show, E : Show, F : Show, G : Show] Show for (A, B, C, D, E, F, G)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show, T9 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show, T9 : Show, T10 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show, T9 : Show, T10 : Show, T11 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show, T9 : Show, T10 : Show, T11 : Show, T12 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show, T9 : Show, T10 : Show, T11 : Show, T12 : Show, T13 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show, T9 : Show, T10 : Show, T11 : Show, T12 : Show, T13 : Show, T14 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
impl[T0 : Show, T1 : Show, T2 : Show, T3 : Show, T4 : Show, T5 : Show, T6 : Show, T7 : Show, T8 : Show, T9 : Show, T10 : Show, T11 : Show, T12 : Show, T13 : Show, T14 : Show, T15 : Show] Show for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

pub(open) trait Shr {
  op_shr(Self, Int) -> Self
}
impl Shr for Byte
impl Shr for Int
impl Shr for Int64
impl Shr for UInt
impl Shr for UInt64

pub(open) trait Sub {
  op_sub(Self, Self) -> Self
}
impl Sub for Byte
impl Sub for Int
impl Sub for Int64
impl Sub for UInt
impl Sub for UInt64
impl Sub for Float
impl Sub for Double

pub(open) trait ToJson {
  to_json(Self) -> Json
}
impl ToJson for Unit
impl ToJson for Bool
impl ToJson for Char
impl ToJson for Int
impl ToJson for Int64
impl ToJson for UInt
impl ToJson for UInt64
impl ToJson for Float
impl ToJson for Double
impl ToJson for String
impl[T : ToJson] ToJson for T?
impl[Ok : ToJson, Err : ToJson] ToJson for Result[Ok, Err]
impl[X : ToJson] ToJson for FixedArray[X]
impl[A : ToJson, B : ToJson] ToJson for (A, B)
impl[A : ToJson, B : ToJson, C : ToJson] ToJson for (A, B, C)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson] ToJson for (A, B, C, D)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson] ToJson for (A, B, C, D, E)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson] ToJson for (A, B, C, D, E, F)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson] ToJson for (A, B, C, D, E, F, G)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson] ToJson for (A, B, C, D, E, F, G, H)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson] ToJson for (A, B, C, D, E, F, G, H, I)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson, J : ToJson] ToJson for (A, B, C, D, E, F, G, H, I, J)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson, J : ToJson, K : ToJson] ToJson for (A, B, C, D, E, F, G, H, I, J, K)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson, J : ToJson, K : ToJson, L : ToJson] ToJson for (A, B, C, D, E, F, G, H, I, J, K, L)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson, J : ToJson, K : ToJson, L : ToJson, M : ToJson] ToJson for (A, B, C, D, E, F, G, H, I, J, K, L, M)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson, J : ToJson, K : ToJson, L : ToJson, M : ToJson, N : ToJson] ToJson for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson, J : ToJson, K : ToJson, L : ToJson, M : ToJson, N : ToJson, O : ToJson] ToJson for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
impl[A : ToJson, B : ToJson, C : ToJson, D : ToJson, E : ToJson, F : ToJson, G : ToJson, H : ToJson, I : ToJson, J : ToJson, K : ToJson, L : ToJson, M : ToJson, N : ToJson, O : ToJson, P : ToJson] ToJson for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)