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!

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

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 print[T : Show](T) -> Unit //deprecated

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

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

type Array
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
  compare[T : Compare](Self[T], Self[T]) -> Int
  contains[T : Eq](Self[T], T) -> Bool
  dedup[T : Eq](Self[T]) -> Unit
  default[T]() -> Self[T]
  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]
  find_index[T](Self[T], (T) -> Bool) -> Int? //deprecated
  flatten[T](Self[Self[T]]) -> Self[T]
  fold[A, B](Self[A], init~ : B, (B, A) -> B) -> B
  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 //deprecated
  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_add[T](Self[T], Self[T]) -> Self[T]
  op_as_view[T](Self[T], start~ : Int = .., end? : Int) -> ArrayView[T]
  op_equal[T : Eq](Self[T], Self[T]) -> Bool
  op_get[T](Self[T], Int) -> T
  op_set[T](Self[T], Int, T) -> Unit
  pop[T](Self[T]) -> T?
  pop_exn[T](Self[T]) -> T //deprecated
  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
  to_json[X : ToJson](Self[X]) -> Json
  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[X : Show] Show for Array[X]

type ArrayView
impl ArrayView {
  filter[T](Self[T], (T) -> Bool) -> Array[T]
  fold[A, B](Self[A], init~ : B, (B, A) -> B) -> B
  foldi[A, B](Self[A], init~ : B, (Int, B, A) -> B) -> B
  iter[A](Self[A]) -> Iter[A]
  length[T](Self[T]) -> Int
  map[T, U](Self[T], (T) -> U) -> Array[U]
  map_inplace[T](Self[T], (T) -> T) -> Unit
  mapi[T, U](Self[T], (Int, T) -> U) -> Array[U]
  mapi_inplace[T](Self[T], (Int, T) -> T) -> Unit
  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
  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
  swap[T](Self[T], Int, Int) -> Unit
  to_json[X : ToJson](Self[X]) -> Json
  unsafe_get[T](Self[T], Int) -> T
}
impl[T : Compare] Compare for ArrayView[T]
impl[T : Eq] Eq for ArrayView[T]
impl[X : Show] Show for ArrayView[X]

type BigInt
impl BigInt {
  asr(Self, Int) -> Self //deprecated
  compare(Self, Self) -> Int
  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
  land(Self, Self) -> Self
  lor(Self, Self) -> Self
  lsl(Self, Int) -> Self //deprecated
  lxor(Self, Self) -> Self
  op_add(Self, Self) -> Self
  op_div(Self, Self) -> Self
  op_equal(Self, Self) -> Bool
  op_mod(Self, Self) -> Self
  op_mul(Self, Self) -> Self
  op_neg(Self) -> Self
  op_shl(Self, Int) -> Self
  op_shr(Self, Int) -> Self
  op_sub(Self, Self) -> Self
  pow(Self, Self, modulus? : Self) -> Self
  shl(Self, Int) -> Self //deprecated
  shr(Self, Int) -> Self //deprecated
  to_hex(Self, uppercase~ : Bool = ..) -> String
  to_int(Self) -> Int
  to_int64(Self) -> Int64
  to_json(Self) -> Json
  to_octets(Self, length? : Int) -> Bytes
  to_string(Self) -> String
  to_uint(Self) -> UInt
  to_uint64(Self) -> UInt64
}
impl Show for BigInt

type BytesView
impl BytesView {
  iter(Self) -> Iter[Byte]
  length(Self) -> Int
  op_as_view(Self, start~ : Int = .., end? : Int) -> Self
  op_get(Self, Int) -> Byte
  to_double_be(Self) -> Double
  to_double_le(Self) -> Double
  to_float_be(Self) -> Float
  to_float_le(Self) -> Float
  to_int64_be(Self) -> Int64
  to_int64_le(Self) -> Int64
  to_int_be(Self) -> Int
  to_int_le(Self) -> Int
  to_uint64_be(Self) -> UInt64
  to_uint64_le(Self) -> UInt64
  to_uint_be(Self) -> UInt
  to_uint_le(Self) -> UInt
  unsafe_get(Self, Int) -> Byte
}
impl Show for BytesView

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
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]
  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]
  just_run[T](Self[T], (T) -> IterResult) -> Unit
  last[A](Self[A]) -> A?
  map[T, R](Self[T], (T) -> R) -> Self[R]
  map_option[A, B](Self[A], (A) -> B?) -> Self[B] //deprecated
  map_while[A, B](Self[A], (A) -> B?) -> Self[B]
  new[T](((T) -> IterResult) -> IterResult) -> Self[T]
  op_add[T](Self[T], Self[T]) -> Self[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 : Show] Show for Iter[T]

type Iter2
impl Iter2 {
  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 {
  default() -> Self
}
impl Eq for Json

type Map
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
  default[K, V]() -> Self[K, V]
  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_equal[K : Hash + Eq, V : Eq](Self[K, V], Self[K, V]) -> Bool
  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)]
  to_json[K : Show, V : ToJson](Self[K, V]) -> Json
  values[K, V](Self[K, V]) -> Iter[V]
}
impl[K : Show, V : Show] Show for Map[K, V]

type Set
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]
  insert[K : Hash + Eq](Self[K], K) -> Unit //deprecated
  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]
  op_equal[K : Eq](Self[K], Self[K]) -> Bool
  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]
  to_json[X : ToJson](Self[X]) -> Json
  union[K : Hash + Eq](Self[K], Self[K]) -> Self[K]
}
impl[K : Show] Show for Set[K]

pub(all) type! SnapshotError String

pub(all) 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_char(Self, Char) -> Unit
  write_object[T : Show](Self, T) -> Unit
  write_string(Self, String) -> Unit
  write_substring(Self, String, Int, Int) -> Unit
}
impl Show for StringBuilder

type UninitializedArray
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 Unit {
  op_equal(Unit, Unit) -> Bool
  to_json(Unit) -> Json
}

impl Bool {
  compare(Bool, Bool) -> Int
  default() -> Bool
  not(Bool) -> Bool //deprecated
  op_compare(Bool, Bool) -> Int //deprecated
  op_equal(Bool, Bool) -> Bool
  to_json(Bool) -> Json
  to_string(Bool) -> String
}

impl Byte {
  compare(Byte, Byte) -> Int
  default() -> Byte
  land(Byte, Byte) -> Byte
  lnot(Byte) -> Byte
  lor(Byte, Byte) -> Byte
  lsl(Byte, Int) -> Byte //deprecated
  lsr(Byte, Int) -> Byte //deprecated
  lxor(Byte, Byte) -> Byte
  op_add(Byte, Byte) -> Byte
  op_div(Byte, Byte) -> Byte
  op_equal(Byte, Byte) -> Bool
  op_mul(Byte, Byte) -> Byte
  op_shl(Byte, Int) -> Byte
  op_shr(Byte, Int) -> Byte
  op_sub(Byte, Byte) -> Byte
  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 {
  compare(Char, Char) -> Int
  default() -> Char
  from_int(Int) -> Char
  op_equal(Char, Char) -> Bool
  op_sub(Char, Char) -> Int
  to_int(Char) -> Int
  to_json(Char) -> Json
  to_string(Char) -> String
  to_uint(Char) -> UInt
}

impl Int {
  asr(Int, Int) -> Int //deprecated
  clz(Int) -> Int
  compare(Int, Int) -> Int
  ctz(Int) -> Int
  default() -> 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
  lsl(Int, Int) -> Int //deprecated
  lsr(Int, Int) -> Int //deprecated
  lxor(Int, Int) -> Int
  op_add(Int, Int) -> Int
  op_div(Int, Int) -> Int
  op_equal(Int, Int) -> Bool
  op_mod(Int, Int) -> Int
  op_mul(Int, Int) -> Int
  op_neg(Int) -> Int
  op_shl(Int, Int) -> Int
  op_shr(Int, Int) -> Int
  op_sub(Int, Int) -> Int
  popcnt(Int) -> Int
  reinterpret_as_float(Int) -> Float
  reinterpret_as_uint(Int) -> UInt
  shl(Int, Int) -> Int //deprecated
  shr(Int, Int) -> Int //deprecated
  to_byte(Int) -> Byte
  to_double(Int) -> Double
  to_float(Int) -> Float
  to_int16(Int) -> Int16
  to_int64(Int) -> Int64
  to_json(Int) -> Json
  to_string(Int) -> String
  to_uint(Int) -> UInt //deprecated
  to_uint16(Int) -> UInt16
  to_uint64(Int) -> UInt64
  until(Int, Int, step~ : Int = .., inclusive~ : Bool = ..) -> Iter[Int]
  upto(Int, Int, inclusive~ : Bool = ..) -> Iter[Int] //deprecated
}

impl Int16 {
  to_byte(Int16) -> Byte
  to_int(Int16) -> Int
  to_int64(Int16) -> Int64
  to_string(Int16) -> String
}

impl Int64 {
  asr(Int64, Int) -> Int64 //deprecated
  clz(Int64) -> Int
  compare(Int64, Int64) -> Int
  ctz(Int64) -> Int
  default() -> Int64
  land(Int64, Int64) -> Int64
  lnot(Int64) -> Int64
  lor(Int64, Int64) -> Int64
  lsl(Int64, Int) -> Int64 //deprecated
  lsr(Int64, Int) -> Int64 //deprecated
  lxor(Int64, Int64) -> Int64
  op_add(Int64, Int64) -> Int64
  op_div(Int64, Int64) -> Int64
  op_equal(Int64, Int64) -> Bool
  op_mod(Int64, Int64) -> Int64
  op_mul(Int64, Int64) -> Int64
  op_neg(Int64) -> Int64
  op_shl(Int64, Int) -> Int64
  op_shr(Int64, Int) -> Int64
  op_sub(Int64, Int64) -> Int64
  popcnt(Int64) -> Int
  reinterpret_as_double(Int64) -> Double
  reinterpret_as_uint64(Int64) -> UInt64
  shl(Int64, Int) -> Int64 //deprecated
  shr(Int64, Int) -> Int64 //deprecated
  to_byte(Int64) -> Byte
  to_double(Int64) -> Double
  to_float(Int64) -> Float
  to_int(Int64) -> Int
  to_int16(Int64) -> Int16
  to_json(Int64) -> Json
  to_string(Int64) -> String
  to_uint16(Int64) -> UInt16
  to_uint64(Int64) -> UInt64 //deprecated
  until(Int64, Int64, step~ : Int64 = .., inclusive~ : Bool = ..) -> Iter[Int64]
  upto(Int64, Int64, inclusive~ : Bool = ..) -> Iter[Int64] //deprecated
}

impl UInt {
  clz(UInt) -> Int
  compare(UInt, UInt) -> Int
  ctz(UInt) -> Int
  land(UInt, UInt) -> UInt
  lnot(UInt) -> UInt
  lor(UInt, UInt) -> UInt
  lsl(UInt, Int) -> UInt //deprecated
  lsr(UInt, Int) -> UInt //deprecated
  lxor(UInt, UInt) -> UInt
  op_add(UInt, UInt) -> UInt
  op_div(UInt, UInt) -> UInt
  op_equal(UInt, UInt) -> Bool
  op_mod(UInt, UInt) -> UInt
  op_mul(UInt, UInt) -> UInt
  op_neq(UInt, UInt) -> Bool
  op_shl(UInt, Int) -> UInt
  op_shr(UInt, Int) -> UInt
  op_sub(UInt, UInt) -> UInt
  popcnt(UInt) -> Int
  reinterpret_as_float(UInt) -> Float
  reinterpret_as_int(UInt) -> Int
  shl(UInt, Int) -> UInt //deprecated
  shr(UInt, Int) -> UInt //deprecated
  to_byte(UInt) -> Byte
  to_float(UInt) -> Float
  to_int(UInt) -> Int //deprecated
  to_json(UInt) -> Json
  to_string(UInt) -> String
  to_uint64(UInt) -> UInt64
  trunc_double(Double) -> UInt
  upto(UInt, UInt, inclusive~ : Bool = ..) -> Iter[UInt] //deprecated
}

impl UInt16 {
  to_byte(UInt16) -> Byte
  to_int(UInt16) -> Int
  to_int64(UInt16) -> Int64
  to_string(UInt16) -> String
}

impl UInt64 {
  clz(UInt64) -> Int
  compare(UInt64, UInt64) -> Int
  ctz(UInt64) -> Int
  default() -> UInt64
  extend_uint(UInt) -> UInt64
  land(UInt64, UInt64) -> UInt64
  lnot(UInt64) -> UInt64
  lor(UInt64, UInt64) -> UInt64
  lsl(UInt64, Int) -> UInt64 //deprecated
  lsr(UInt64, Int) -> UInt64 //deprecated
  lxor(UInt64, UInt64) -> UInt64
  op_add(UInt64, UInt64) -> UInt64
  op_div(UInt64, UInt64) -> UInt64
  op_equal(UInt64, UInt64) -> Bool
  op_mod(UInt64, UInt64) -> UInt64
  op_mul(UInt64, UInt64) -> UInt64
  op_shl(UInt64, Int) -> UInt64
  op_shr(UInt64, Int) -> UInt64
  op_sub(UInt64, UInt64) -> UInt64
  popcnt(UInt64) -> Int
  reinterpret_as_double(UInt64) -> Double
  reinterpret_as_int64(UInt64) -> Int64
  shl(UInt64, Int) -> UInt64 //deprecated
  shr(UInt64, Int) -> UInt64 //deprecated
  to_byte(UInt64) -> Byte
  to_double(UInt64) -> Double
  to_float(UInt64) -> Float
  to_int(UInt64) -> Int
  to_int64(UInt64) -> Int64 //deprecated
  to_json(UInt64) -> Json
  to_string(UInt64) -> String
  to_uint(UInt64) -> UInt
  trunc_double(Double) -> UInt64
  upto(UInt64, UInt64, inclusive~ : Bool = ..) -> Iter[UInt64] //deprecated
}

impl Float {
  compare(Float, Float) -> Int
  op_add(Float, Float) -> Float
  op_div(Float, Float) -> Float
  op_equal(Float, Float) -> Bool
  op_mul(Float, Float) -> Float
  op_neg(Float) -> Float
  op_neq(Float, Float) -> Bool
  op_sub(Float, Float) -> Float
  reinterpret_as_int(Float) -> Int
  reinterpret_as_uint(Float) -> UInt
  sqrt(Float) -> Float
  to_double(Float) -> Double
  to_json(Float) -> Json
  until(Float, Float, step~ : Float = .., inclusive~ : Bool = ..) -> Iter[Float]
  upto(Float, Float, inclusive~ : Bool = ..) -> Iter[Float] //deprecated
}

impl Double {
  compare(Double, Double) -> Int
  convert_uint(UInt) -> Double
  convert_uint64(UInt64) -> Double
  default() -> Double
  op_add(Double, Double) -> Double
  op_div(Double, Double) -> Double
  op_equal(Double, Double) -> Bool
  op_mul(Double, Double) -> Double
  op_neg(Double) -> Double
  op_neq(Double, Double) -> Bool
  op_sub(Double, Double) -> Double
  reinterpret_as_i64(Double) -> Int64 //deprecated
  reinterpret_as_int64(Double) -> Int64
  reinterpret_as_u64(Double) -> UInt64 //deprecated
  reinterpret_as_uint64(Double) -> UInt64
  sqrt(Double) -> Double
  to_float(Double) -> Float
  to_int(Double) -> Int
  to_int64(Double) -> Int64
  to_json(Double) -> Json
  to_uint64(Double) -> UInt64
  until(Double, Double, step~ : Double = .., inclusive~ : Bool = ..) -> Iter[Double]
  upto(Double, Double, inclusive~ : Bool = ..) -> Iter[Double] //deprecated
}

impl String {
  escape(String) -> String
  get(String, Int) -> Char
  length(String) -> Int
  make(Int, Char) -> String
  op_add(String, String) -> String
  op_equal(String, String) -> Bool
  op_get(String, Int) -> Char
  substring(String, start~ : Int = .., end? : Int) -> String
  to_json(String) -> Json
  to_string(String) -> String
}

impl Option {
  op_equal[X : Eq](X?, X?) -> Bool
  to_json[T : ToJson](T?) -> Json
  to_string[X : Show](X?) -> String
  unwrap[X](X?) -> X
}

impl Result {
  op_equal[T : Eq, E : Eq](Self[T, E], Self[T, E]) -> Bool
  to_json[Ok : ToJson, Err : ToJson](Self[Ok, Err]) -> Json
}

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
  compare[T : Compare](Self[T], Self[T]) -> Int
  default[X]() -> Self[X]
  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_utf16_char(Self[Byte], Int, Char) -> Int //deprecated
  set_utf16be_char(Self[Byte], Int, Char) -> Int
  set_utf16le_char(Self[Byte], Int, Char) -> Int
  set_utf8_char(Self[Byte], Int, Char) -> Int
  to_json[X : ToJson](Self[X]) -> Json
  unsafe_blit[A](Self[A], Int, Self[A], Int, Int) -> Unit
  unsafe_get[T](Self[T], Int) -> T
}

impl Bytes {
  blit(Bytes, Int, Bytes, Int, Int) -> Unit
  copy(Bytes) -> Bytes
  length(Bytes) -> Int
  make(Int, Byte) -> Bytes
  makei(Int, (Int) -> Byte) -> Bytes
  new(Int) -> Bytes
  of_string(String) -> Bytes
  op_as_view(Bytes, start~ : Int = .., end? : Int) -> BytesView
  op_equal(Bytes, Bytes) -> Bool
  op_get(Bytes, Int) -> Byte
  op_set(Bytes, Int, Byte) -> Unit //deprecated
  sub_string(Bytes, Int, Int) -> String //deprecated
  to_string(Bytes) -> String //deprecated
  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
}

impl Tuple(2) {
  compare[T0 : Compare, T1 : Compare]((T0, T1), (T0, T1)) -> Int
  op_equal[T0 : Eq, T1 : Eq]((T0, T1), (T0, T1)) -> Bool
}

impl Tuple(3) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare]((T0, T1, T2), (T0, T1, T2)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq]((T0, T1, T2), (T0, T1, T2)) -> Bool
}

impl Tuple(4) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare]((T0, T1, T2, T3), (T0, T1, T2, T3)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq]((T0, T1, T2, T3), (T0, T1, T2, T3)) -> Bool
}

impl Tuple(5) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare]((T0, T1, T2, T3, T4), (T0, T1, T2, T3, T4)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq]((T0, T1, T2, T3, T4), (T0, T1, T2, T3, T4)) -> Bool
}

impl Tuple(6) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare]((T0, T1, T2, T3, T4, T5), (T0, T1, T2, T3, T4, T5)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq]((T0, T1, T2, T3, T4, T5), (T0, T1, T2, T3, T4, T5)) -> Bool
}

impl Tuple(7) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare]((T0, T1, T2, T3, T4, T5, T6), (T0, T1, T2, T3, T4, T5, T6)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq]((T0, T1, T2, T3, T4, T5, T6), (T0, T1, T2, T3, T4, T5, T6)) -> Bool
}

impl Tuple(8) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare]((T0, T1, T2, T3, T4, T5, T6, T7), (T0, T1, T2, T3, T4, T5, T6, T7)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq]((T0, T1, T2, T3, T4, T5, T6, T7), (T0, T1, T2, T3, T4, T5, T6, T7)) -> Bool
}

impl Tuple(9) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare]((T0, T1, T2, T3, T4, T5, T6, T7, T8), (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq]((T0, T1, T2, T3, T4, T5, T6, T7, T8), (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Bool
}

impl Tuple(10) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Bool
}

impl Tuple(11) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Bool
}

impl Tuple(12) {
  compare[T0 : Compare, T1 : Compare, T2 : Compare, T3 : Compare, T4 : Compare, T5 : Compare, T6 : Compare, T7 : Compare, T8 : Compare, T9 : Compare, T10 : Compare, T11 : Compare]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Int
  op_equal[T0 : Eq, T1 : Eq, T2 : Eq, T3 : Eq, T4 : Eq, T5 : Eq, T6 : Eq, T7 : Eq, T8 : Eq, T9 : Eq, T10 : Eq, T11 : Eq]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Bool
}

impl Tuple(13) {
  compare[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Int
  op_equal[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Bool
}

impl Tuple(14) {
  compare[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Int
  op_equal[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Bool
}

impl Tuple(15) {
  compare[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Int
  op_equal[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Bool
}

impl Tuple(16) {
  compare[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Int
  op_equal[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]((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Bool
}

// Type aliases

// Traits
pub(open) trait Compare : Eq {
  compare(Self, Self) -> Int
}

pub(open) trait Default {
  default() -> Self
}

pub(open) trait Eq {
  op_equal(Self, Self) -> Bool
}

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_sub_string(Self, String, Int, Int) -> Unit
  write_char(Self, Char) -> Unit
}
impl Logger::write_sub_string

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 ToJson {
  to_json(Self) -> Json
}
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)