std/int
import std/int to use it. Source: src/std/int.iyi at v0.18.0.
The prelude declares arithmetic, comparison and conversion primitives for its four integer types and Float64 only; a literal 1_u16 exists, but 1_u16 + 1_u16 has no method to land on. This module declares the rest of the matrix the same way the prelude does - @[Primitive] annotations the compiler lowers to instructions, no library underneath - so every pair of integer types adds, subtracts, multiplies, compares and converts; then gives each type the operators the prelude writes by hand (//, %, <<, >>, abs, unary -) and a printer, and every integer the bit counts (popcount, leading_zeros_count, trailing_zeros_count, bit_length, bit), gcd/lcm, digits, <=>, and chr with the prelude's contract.
What it refuses: arithmetic that leaves the type panics with "arithmetic overflow" (the &+ family wraps instead); a conversion that does not fit panics the same way, the to_i8? family answers nil instead, and the unsafe_to_i8 family keeps the low bits; a double converts by truncating first, so 127.9.to_i8 is 127 and (-0.5).to_u16 is 0, and what is refused is a truncation the type does not hold; // and % by zero panic "division by zero" / "modulo by zero"; digits of a negative number, a base under 2, a chr of a surrogate or past 0x10FFFF, and a to_s base outside 2..36 are refused with a sentence. There is no Int32::MAX: the edges of a type are its literals, and that holds for every type here.
Against a double every integer compares exactly, <=> included: 9007199254740993_i128 == 9007199254740992.0 is false. The prelude's own four (Int32, Int64, UInt8, UInt64) keep the prelude's == family, which is exact as well and agrees with their <=> here.
Float64struct, reopened
struct ::Float64
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt16) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt128) : Bool
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int128) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt128) : self
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int128) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt128) : self
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int128) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt128) : self
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int128) : Bool
def <(other : UInt16) : Bool
def <(other : UInt32) : Bool
def <(other : UInt128) : Bool
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt16) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt128) : Bool
# The integer's comparison, exact, with the sides swapped.
def ==(other : Int8) : Bool
# The integer's comparison, exact, with the sides swapped.
def ==(other : Int16) : Bool
# The integer's comparison, exact, with the sides swapped.
def ==(other : Int128) : Bool
# The integer's comparison, exact, with the sides swapped.
def ==(other : UInt16) : Bool
# The integer's comparison, exact, with the sides swapped.
def ==(other : UInt32) : Bool
# The integer's comparison, exact, with the sides swapped.
def ==(other : UInt128) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int128) : Bool
def >(other : UInt16) : Bool
def >(other : UInt32) : Bool
def >(other : UInt128) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt16) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt128) : Bool
def fdiv(other : Int8) : self
def fdiv(other : Int16) : self
def fdiv(other : Int128) : self
def fdiv(other : UInt16) : self
def fdiv(other : UInt32) : self
def fdiv(other : UInt128) : self
def to_i128 : Int128
def to_i16 : Int16
def to_i8 : Int8
def to_u : UInt32
def to_u128 : UInt128
def to_u16 : UInt16
def to_u32 : UInt32
# Not the instruction: a double to a 128-bit integer is a call
# into compiler-rt (`__fixdfti`) on aarch64, which the floor
# (SPEC.md III.9) does not link. The mantissa and exponent are
# read off the bits and shifted into place instead; the caller
# has already refused what does not fit.
def unsafe_to_i128 : Int128
# The prelude declares the unchecked form for its own five, as it
# declares the checked one, so declaring it here too would be R-3's
# duplicate.
def unsafe_to_i16 : Int16
# The conversions to the integers the prelude does not reach. The
# unchecked form saturates, as the prelude's does - past the range it is
# the nearest bound and NaN is 0, in every build and on every target -
# but for the two 128-bit ones below; the checked form truncates first
# and refuses what the truncation does not hold:
# `127.9.to_i8` is 127 and `(-0.5).to_u16` is 0, where the range was
# once checked on the untruncated value and both were refused. NaN and
# the infinities are refused. The prelude's own five (`to_i`, `to_i32`,
# `to_i64`, `to_u8`, `to_u64`) are the compiler's and say the same.
# The prelude declares the unchecked form for its own five, as it
# declares the checked one, so declaring it here too would be R-3's
# duplicate.
def unsafe_to_i8 : Int8
# The prelude declares the unchecked form for its own five, as it
# declares the checked one, so declaring it here too would be R-3's
# duplicate.
def unsafe_to_u : UInt32
# Not the instruction: a double to a 128-bit integer is a call
# into compiler-rt (`__fixdfti`) on aarch64, which the floor
# (SPEC.md III.9) does not link. The mantissa and exponent are
# read off the bits and shifted into place instead; the caller
# has already refused what does not fit.
def unsafe_to_u128 : UInt128
# The prelude declares the unchecked form for its own five, as it
# declares the checked one, so declaring it here too would be R-3's
# duplicate.
def unsafe_to_u16 : UInt16
# The prelude declares the unchecked form for its own five, as it
# declares the checked one, so declaring it here too would be R-3's
# duplicate.
def unsafe_to_u32 : UInt32
endIntstruct, reopened
struct ::Int
# Against any integer, as the other library's `Int#<=>` is, the widths
# compared exactly by the primitives above. Against `self` only, an
# `Int64` beside an `Int32` did not type, and once `std/traits` added
# `Int32#<=>(Int32)` the literal in `1 <=> 1_i64` cast to that and to
# `Float64` both: "ambiguous call" where the other library answers 0.
def <=>(other : ::Int) : Int32
# Bit `n`, 0 or 1; a bit past the width is 0 (or the sign).
def bit(n : Int32) : Int32
def bits_set?(mask : self) : Bool
# The character with this code point: the prelude's `Int32#chr` contract
# for every integer type, every code point but the surrogates. It stopped
# at ASCII after the prelude's had moved on, so `233.chr` was 'é' and
# `233_i64.chr` panicked "233 is out of char range".
def chr : Char
# The digits, least significant first: `1234.digits` is `[4, 3, 2, 1]`.
# A negative number has no digits in this sense and is refused.
def digits(base : Int32 = 10) : Array(Int32)
# Euclid on the side of zero where every magnitude fits, as `Math.gcd`
# works: the non-positive side for a signed type, its minimum included.
# Taking `abs` first refused the minimum, and `(-2147483648).gcd(6)`
# panicked "arithmetic overflow" where `Math.gcd` answered 2. Only
# gcd(minimum, 0), whose answer does not fit, overflows.
def gcd(other : self) : self
def lcm(other : self) : self
endInt128struct, reopened
struct ::Int128
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int32) : Bool
def !=(other : Int64) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt8) : Bool
def !=(other : UInt16) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt64) : Bool
def !=(other : UInt128) : Bool
def !=(other : Float64) : Bool
def %(other : Int128) : Int128
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int32) : self
def &(other : Int64) : self
def &(other : Int128) : self
def &(other : UInt8) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt64) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int32) : self
def &*(other : Int64) : self
def &*(other : Int128) : self
def &*(other : UInt8) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt64) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int32) : self
def &+(other : Int64) : self
def &+(other : Int128) : self
def &+(other : UInt8) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt64) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int32) : self
def &-(other : Int64) : self
def &-(other : Int128) : self
def &-(other : UInt8) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt64) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int32) : self
def *(other : Int64) : self
def *(other : Int128) : self
def *(other : UInt8) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt64) : self
def *(other : UInt128) : self
def *(other : Float64) : Float64
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int32) : self
def +(other : Int64) : self
def +(other : Int128) : self
def +(other : UInt8) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt64) : self
def +(other : UInt128) : self
def +(other : Float64) : Float64
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int32) : self
def -(other : Int64) : self
def -(other : Int128) : self
def -(other : UInt8) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt64) : self
def -(other : UInt128) : self
def -(other : Float64) : Float64
def - : Int128
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
# The zero is checked here rather than left to the processor, which
# reports an integer division by zero as a floating-point fault.
def //(other : Int128) : Int128
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int32) : Bool
def <(other : Int64) : Bool
def <(other : Int128) : Bool
def <(other : UInt8) : Bool
def <(other : UInt16) : Bool
def <(other : UInt32) : Bool
def <(other : UInt64) : Bool
def <(other : UInt128) : Bool
def <(other : Float64) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : Int128
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int32) : Bool
def <=(other : Int64) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt8) : Bool
def <=(other : UInt16) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt64) : Bool
def <=(other : UInt128) : Bool
def <=(other : Float64) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
# A value this wide may not be a double: `9007199254740993_i128 ==
# 9007199254740992.0` was true, the integer rounded to the double
# before the comparison. `<=>` below compares exactly.
# IEEE against NaN: only `!=` is true. `<=>` places NaN for
# sorting and would answer `<` here.
def ==(other : Float64) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int32) : Bool
def >(other : Int64) : Bool
def >(other : Int128) : Bool
def >(other : UInt8) : Bool
def >(other : UInt16) : Bool
def >(other : UInt32) : Bool
def >(other : UInt64) : Bool
def >(other : UInt128) : Bool
def >(other : Float64) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int32) : Bool
def >=(other : Int64) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt8) : Bool
def >=(other : UInt16) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt64) : Bool
def >=(other : UInt128) : Bool
def >=(other : Float64) : Bool
def >>(count : Int32) : Int128
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int32) : self
def ^(other : Int64) : self
def ^(other : Int128) : self
def ^(other : UInt8) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt64) : self
def ^(other : UInt128) : self
def abs : Int128
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def hash : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_f : Float64
def to_f64 : Float64
def to_i : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32 : Int32
def to_i32? : Int32 | ::Nil
def to_i64 : Int64
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_s(base : Int32) : String
# Digits backward, the negative magnitude divided rather than
# negated so the smallest value prints (its negation is not one of
# the type).
def to_s : String
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64 : UInt64
def to_u64? : UInt64 | ::Nil
def to_u8 : UInt8
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_chr : Char
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int32) : self
def unsafe_div(other : Int64) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt8) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt64) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int32) : self
def unsafe_mod(other : Int64) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt8) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt64) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int32) : self
def unsafe_shl(other : Int64) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt8) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt64) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int32) : self
def unsafe_shr(other : Int64) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt8) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt64) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i : Int32
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i32 : Int32
def unsafe_to_i64 : Int64
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def unsafe_to_u64 : UInt64
def unsafe_to_u8 : UInt8
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int32) : self
def |(other : Int64) : self
def |(other : Int128) : self
def |(other : UInt8) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt64) : self
def |(other : UInt128) : self
def ~ : Int128
endInt16struct, reopened
struct ::Int16
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int32) : Bool
def !=(other : Int64) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt8) : Bool
def !=(other : UInt16) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt64) : Bool
def !=(other : UInt128) : Bool
def !=(other : Float64) : Bool
def %(other : Int16) : Int16
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int32) : self
def &(other : Int64) : self
def &(other : Int128) : self
def &(other : UInt8) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt64) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int32) : self
def &*(other : Int64) : self
def &*(other : Int128) : self
def &*(other : UInt8) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt64) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int32) : self
def &+(other : Int64) : self
def &+(other : Int128) : self
def &+(other : UInt8) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt64) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int32) : self
def &-(other : Int64) : self
def &-(other : Int128) : self
def &-(other : UInt8) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt64) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int32) : self
def *(other : Int64) : self
def *(other : Int128) : self
def *(other : UInt8) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt64) : self
def *(other : UInt128) : self
def *(other : Float64) : Float64
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int32) : self
def +(other : Int64) : self
def +(other : Int128) : self
def +(other : UInt8) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt64) : self
def +(other : UInt128) : self
def +(other : Float64) : Float64
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int32) : self
def -(other : Int64) : self
def -(other : Int128) : self
def -(other : UInt8) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt64) : self
def -(other : UInt128) : self
def -(other : Float64) : Float64
def - : Int16
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
# The zero is checked here rather than left to the processor, which
# reports an integer division by zero as a floating-point fault.
def //(other : Int16) : Int16
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int32) : Bool
def <(other : Int64) : Bool
def <(other : Int128) : Bool
def <(other : UInt8) : Bool
def <(other : UInt16) : Bool
def <(other : UInt32) : Bool
def <(other : UInt64) : Bool
def <(other : UInt128) : Bool
def <(other : Float64) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : Int16
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int32) : Bool
def <=(other : Int64) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt8) : Bool
def <=(other : UInt16) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt64) : Bool
def <=(other : UInt128) : Bool
def <=(other : Float64) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
# Every value of the type is a double exactly, so the double's own
# comparison is the exact one.
def ==(other : Float64) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int32) : Bool
def >(other : Int64) : Bool
def >(other : Int128) : Bool
def >(other : UInt8) : Bool
def >(other : UInt16) : Bool
def >(other : UInt32) : Bool
def >(other : UInt64) : Bool
def >(other : UInt128) : Bool
def >(other : Float64) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int32) : Bool
def >=(other : Int64) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt8) : Bool
def >=(other : UInt16) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt64) : Bool
def >=(other : UInt128) : Bool
def >=(other : Float64) : Bool
def >>(count : Int32) : Int16
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int32) : self
def ^(other : Int64) : self
def ^(other : Int128) : self
def ^(other : UInt8) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt64) : self
def ^(other : UInt128) : self
def abs : Int16
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def hash : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_f : Float64
def to_f64 : Float64
def to_i : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32 : Int32
def to_i32? : Int32 | ::Nil
def to_i64 : Int64
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_s(base : Int32) : String
# Fits an `Int64`: the prelude's printer.
def to_s : String
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64 : UInt64
def to_u64? : UInt64 | ::Nil
def to_u8 : UInt8
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_chr : Char
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int32) : self
def unsafe_div(other : Int64) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt8) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt64) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int32) : self
def unsafe_mod(other : Int64) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt8) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt64) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int32) : self
def unsafe_shl(other : Int64) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt8) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt64) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int32) : self
def unsafe_shr(other : Int64) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt8) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt64) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i : Int32
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i32 : Int32
def unsafe_to_i64 : Int64
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def unsafe_to_u64 : UInt64
def unsafe_to_u8 : UInt8
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int32) : self
def |(other : Int64) : self
def |(other : Int128) : self
def |(other : UInt8) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt64) : self
def |(other : UInt128) : self
def ~ : Int16
endInt32struct, reopened
struct ::Int32
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt128) : Bool
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int128) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int128) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int128) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int128) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int128) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt128) : self
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int128) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt128) : self
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int128) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt128) : self
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int128) : Bool
def <(other : UInt32) : Bool
def <(other : UInt128) : Bool
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt128) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int128) : Bool
def >(other : UInt32) : Bool
def >(other : UInt128) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt128) : Bool
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int128) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt128) : self
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32? : Int32 | ::Nil
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64? : UInt64 | ::Nil
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int128) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt128) : self
def ~ : Int32
endInt64struct, reopened
struct ::Int64
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt128) : Bool
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int128) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int128) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int128) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int128) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int128) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt128) : self
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int128) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt128) : self
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int128) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt128) : self
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int128) : Bool
def <(other : UInt32) : Bool
def <(other : UInt128) : Bool
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt128) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int128) : Bool
def >(other : UInt32) : Bool
def >(other : UInt128) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt128) : Bool
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int128) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt128) : self
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32? : Int32 | ::Nil
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64? : UInt64 | ::Nil
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int128) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt128) : self
def ~ : Int64
endInt8struct, reopened
struct ::Int8
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int32) : Bool
def !=(other : Int64) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt8) : Bool
def !=(other : UInt16) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt64) : Bool
def !=(other : UInt128) : Bool
def !=(other : Float64) : Bool
def %(other : Int8) : Int8
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int32) : self
def &(other : Int64) : self
def &(other : Int128) : self
def &(other : UInt8) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt64) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int32) : self
def &*(other : Int64) : self
def &*(other : Int128) : self
def &*(other : UInt8) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt64) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int32) : self
def &+(other : Int64) : self
def &+(other : Int128) : self
def &+(other : UInt8) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt64) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int32) : self
def &-(other : Int64) : self
def &-(other : Int128) : self
def &-(other : UInt8) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt64) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int32) : self
def *(other : Int64) : self
def *(other : Int128) : self
def *(other : UInt8) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt64) : self
def *(other : UInt128) : self
def *(other : Float64) : Float64
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int32) : self
def +(other : Int64) : self
def +(other : Int128) : self
def +(other : UInt8) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt64) : self
def +(other : UInt128) : self
def +(other : Float64) : Float64
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int32) : self
def -(other : Int64) : self
def -(other : Int128) : self
def -(other : UInt8) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt64) : self
def -(other : UInt128) : self
def -(other : Float64) : Float64
def - : Int8
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
# The zero is checked here rather than left to the processor, which
# reports an integer division by zero as a floating-point fault.
def //(other : Int8) : Int8
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int32) : Bool
def <(other : Int64) : Bool
def <(other : Int128) : Bool
def <(other : UInt8) : Bool
def <(other : UInt16) : Bool
def <(other : UInt32) : Bool
def <(other : UInt64) : Bool
def <(other : UInt128) : Bool
def <(other : Float64) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : Int8
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int32) : Bool
def <=(other : Int64) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt8) : Bool
def <=(other : UInt16) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt64) : Bool
def <=(other : UInt128) : Bool
def <=(other : Float64) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
# Every value of the type is a double exactly, so the double's own
# comparison is the exact one.
def ==(other : Float64) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int32) : Bool
def >(other : Int64) : Bool
def >(other : Int128) : Bool
def >(other : UInt8) : Bool
def >(other : UInt16) : Bool
def >(other : UInt32) : Bool
def >(other : UInt64) : Bool
def >(other : UInt128) : Bool
def >(other : Float64) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int32) : Bool
def >=(other : Int64) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt8) : Bool
def >=(other : UInt16) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt64) : Bool
def >=(other : UInt128) : Bool
def >=(other : Float64) : Bool
def >>(count : Int32) : Int8
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int32) : self
def ^(other : Int64) : self
def ^(other : Int128) : self
def ^(other : UInt8) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt64) : self
def ^(other : UInt128) : self
def abs : Int8
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def hash : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_f : Float64
def to_f64 : Float64
def to_i : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32 : Int32
def to_i32? : Int32 | ::Nil
def to_i64 : Int64
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_s(base : Int32) : String
# Fits an `Int64`: the prelude's printer.
def to_s : String
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64 : UInt64
def to_u64? : UInt64 | ::Nil
def to_u8 : UInt8
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_chr : Char
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int32) : self
def unsafe_div(other : Int64) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt8) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt64) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int32) : self
def unsafe_mod(other : Int64) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt8) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt64) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int32) : self
def unsafe_shl(other : Int64) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt8) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt64) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int32) : self
def unsafe_shr(other : Int64) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt8) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt64) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i : Int32
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i32 : Int32
def unsafe_to_i64 : Int64
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def unsafe_to_u64 : UInt64
def unsafe_to_u8 : UInt8
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int32) : self
def |(other : Int64) : self
def |(other : Int128) : self
def |(other : UInt8) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt64) : self
def |(other : UInt128) : self
def ~ : Int8
endUInt128struct, reopened
struct ::UInt128
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int32) : Bool
def !=(other : Int64) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt8) : Bool
def !=(other : UInt16) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt64) : Bool
def !=(other : UInt128) : Bool
def !=(other : Float64) : Bool
def %(other : UInt128) : UInt128
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int32) : self
def &(other : Int64) : self
def &(other : Int128) : self
def &(other : UInt8) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt64) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int32) : self
def &*(other : Int64) : self
def &*(other : Int128) : self
def &*(other : UInt8) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt64) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int32) : self
def &+(other : Int64) : self
def &+(other : Int128) : self
def &+(other : UInt8) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt64) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int32) : self
def &-(other : Int64) : self
def &-(other : Int128) : self
def &-(other : UInt8) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt64) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int32) : self
def *(other : Int64) : self
def *(other : Int128) : self
def *(other : UInt8) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt64) : self
def *(other : UInt128) : self
def *(other : Float64) : Float64
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int32) : self
def +(other : Int64) : self
def +(other : Int128) : self
def +(other : UInt8) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt64) : self
def +(other : UInt128) : self
def +(other : Float64) : Float64
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int32) : self
def -(other : Int64) : self
def -(other : Int128) : self
def -(other : UInt8) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt64) : self
def -(other : UInt128) : self
def -(other : Float64) : Float64
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
# The zero is checked here rather than left to the processor, which
# reports an integer division by zero as a floating-point fault.
def //(other : UInt128) : UInt128
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int32) : Bool
def <(other : Int64) : Bool
def <(other : Int128) : Bool
def <(other : UInt8) : Bool
def <(other : UInt16) : Bool
def <(other : UInt32) : Bool
def <(other : UInt64) : Bool
def <(other : UInt128) : Bool
def <(other : Float64) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : UInt128
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int32) : Bool
def <=(other : Int64) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt8) : Bool
def <=(other : UInt16) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt64) : Bool
def <=(other : UInt128) : Bool
def <=(other : Float64) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
# A value this wide may not be a double: `9007199254740993_i128 ==
# 9007199254740992.0` was true, the integer rounded to the double
# before the comparison. `<=>` below compares exactly.
# IEEE against NaN: only `!=` is true. `<=>` places NaN for
# sorting and would answer `<` here.
def ==(other : Float64) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int32) : Bool
def >(other : Int64) : Bool
def >(other : Int128) : Bool
def >(other : UInt8) : Bool
def >(other : UInt16) : Bool
def >(other : UInt32) : Bool
def >(other : UInt64) : Bool
def >(other : UInt128) : Bool
def >(other : Float64) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int32) : Bool
def >=(other : Int64) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt8) : Bool
def >=(other : UInt16) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt64) : Bool
def >=(other : UInt128) : Bool
def >=(other : Float64) : Bool
def >>(count : Int32) : UInt128
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int32) : self
def ^(other : Int64) : self
def ^(other : Int128) : self
def ^(other : UInt8) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt64) : self
def ^(other : UInt128) : self
def abs : UInt128
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def hash : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_f : Float64
def to_f64 : Float64
def to_i : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32 : Int32
def to_i32? : Int32 | ::Nil
def to_i64 : Int64
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_s(base : Int32) : String
# Digits backward, the negative magnitude divided rather than
# negated so the smallest value prints (its negation is not one of
# the type).
def to_s : String
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64 : UInt64
def to_u64? : UInt64 | ::Nil
def to_u8 : UInt8
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_chr : Char
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int32) : self
def unsafe_div(other : Int64) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt8) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt64) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int32) : self
def unsafe_mod(other : Int64) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt8) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt64) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int32) : self
def unsafe_shl(other : Int64) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt8) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt64) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int32) : self
def unsafe_shr(other : Int64) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt8) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt64) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i : Int32
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i32 : Int32
def unsafe_to_i64 : Int64
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def unsafe_to_u64 : UInt64
def unsafe_to_u8 : UInt8
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int32) : self
def |(other : Int64) : self
def |(other : Int128) : self
def |(other : UInt8) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt64) : self
def |(other : UInt128) : self
def ~ : UInt128
endUInt16struct, reopened
struct ::UInt16
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt128) : Bool
def !=(other : Float64) : Bool
def %(other : UInt16) : UInt16
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int32) : self
def &(other : Int64) : self
def &(other : Int128) : self
def &(other : UInt8) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt64) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int32) : self
def &*(other : Int64) : self
def &*(other : Int128) : self
def &*(other : UInt8) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt64) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int32) : self
def &+(other : Int64) : self
def &+(other : Int128) : self
def &+(other : UInt8) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt64) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int32) : self
def &-(other : Int64) : self
def &-(other : Int128) : self
def &-(other : UInt8) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt64) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int32) : self
def *(other : Int64) : self
def *(other : Int128) : self
def *(other : UInt8) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt64) : self
def *(other : UInt128) : self
def *(other : Float64) : Float64
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int32) : self
def +(other : Int64) : self
def +(other : Int128) : self
def +(other : UInt8) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt64) : self
def +(other : UInt128) : self
def +(other : Float64) : Float64
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int32) : self
def -(other : Int64) : self
def -(other : Int128) : self
def -(other : UInt8) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt64) : self
def -(other : UInt128) : self
def -(other : Float64) : Float64
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
# The zero is checked here rather than left to the processor, which
# reports an integer division by zero as a floating-point fault.
def //(other : UInt16) : UInt16
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int128) : Bool
def <(other : UInt32) : Bool
def <(other : UInt128) : Bool
def <(other : Float64) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : UInt16
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt128) : Bool
def <=(other : Float64) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
# Every value of the type is a double exactly, so the double's own
# comparison is the exact one.
def ==(other : Float64) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int128) : Bool
def >(other : UInt32) : Bool
def >(other : UInt128) : Bool
def >(other : Float64) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt128) : Bool
def >=(other : Float64) : Bool
def >>(count : Int32) : UInt16
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int32) : self
def ^(other : Int64) : self
def ^(other : Int128) : self
def ^(other : UInt8) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt64) : self
def ^(other : UInt128) : self
def abs : UInt16
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def hash : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_f : Float64
def to_f64 : Float64
def to_i : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32 : Int32
def to_i32? : Int32 | ::Nil
def to_i64 : Int64
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_s(base : Int32) : String
# Fits an `Int64`: the prelude's printer.
def to_s : String
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64 : UInt64
def to_u64? : UInt64 | ::Nil
def to_u8 : UInt8
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_chr : Char
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int32) : self
def unsafe_div(other : Int64) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt8) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt64) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int32) : self
def unsafe_mod(other : Int64) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt8) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt64) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int32) : self
def unsafe_shl(other : Int64) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt8) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt64) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int32) : self
def unsafe_shr(other : Int64) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt8) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt64) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i : Int32
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i32 : Int32
def unsafe_to_i64 : Int64
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def unsafe_to_u64 : UInt64
def unsafe_to_u8 : UInt8
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int32) : self
def |(other : Int64) : self
def |(other : Int128) : self
def |(other : UInt8) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt64) : self
def |(other : UInt128) : self
def ~ : UInt16
endUInt32struct, reopened
struct ::UInt32
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int32) : Bool
def !=(other : Int64) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt8) : Bool
def !=(other : UInt16) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt64) : Bool
def !=(other : UInt128) : Bool
def !=(other : Float64) : Bool
def %(other : UInt32) : UInt32
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int32) : self
def &(other : Int64) : self
def &(other : Int128) : self
def &(other : UInt8) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt64) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int32) : self
def &*(other : Int64) : self
def &*(other : Int128) : self
def &*(other : UInt8) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt64) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int32) : self
def &+(other : Int64) : self
def &+(other : Int128) : self
def &+(other : UInt8) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt64) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int32) : self
def &-(other : Int64) : self
def &-(other : Int128) : self
def &-(other : UInt8) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt64) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int32) : self
def *(other : Int64) : self
def *(other : Int128) : self
def *(other : UInt8) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt64) : self
def *(other : UInt128) : self
def *(other : Float64) : Float64
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int32) : self
def +(other : Int64) : self
def +(other : Int128) : self
def +(other : UInt8) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt64) : self
def +(other : UInt128) : self
def +(other : Float64) : Float64
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int32) : self
def -(other : Int64) : self
def -(other : Int128) : self
def -(other : UInt8) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt64) : self
def -(other : UInt128) : self
def -(other : Float64) : Float64
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
# The zero is checked here rather than left to the processor, which
# reports an integer division by zero as a floating-point fault.
def //(other : UInt32) : UInt32
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int32) : Bool
def <(other : Int64) : Bool
def <(other : Int128) : Bool
def <(other : UInt8) : Bool
def <(other : UInt16) : Bool
def <(other : UInt32) : Bool
def <(other : UInt64) : Bool
def <(other : UInt128) : Bool
def <(other : Float64) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : UInt32
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int32) : Bool
def <=(other : Int64) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt8) : Bool
def <=(other : UInt16) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt64) : Bool
def <=(other : UInt128) : Bool
def <=(other : Float64) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt64) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
# Every value of the type is a double exactly, so the double's own
# comparison is the exact one.
def ==(other : Float64) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int32) : Bool
def >(other : Int64) : Bool
def >(other : Int128) : Bool
def >(other : UInt8) : Bool
def >(other : UInt16) : Bool
def >(other : UInt32) : Bool
def >(other : UInt64) : Bool
def >(other : UInt128) : Bool
def >(other : Float64) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int32) : Bool
def >=(other : Int64) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt8) : Bool
def >=(other : UInt16) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt64) : Bool
def >=(other : UInt128) : Bool
def >=(other : Float64) : Bool
def >>(count : Int32) : UInt32
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int32) : self
def ^(other : Int64) : self
def ^(other : Int128) : self
def ^(other : UInt8) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt64) : self
def ^(other : UInt128) : self
def abs : UInt32
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def hash : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_f : Float64
def to_f64 : Float64
def to_i : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32 : Int32
def to_i32? : Int32 | ::Nil
def to_i64 : Int64
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_s(base : Int32) : String
# Fits an `Int64`: the prelude's printer.
def to_s : String
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64 : UInt64
def to_u64? : UInt64 | ::Nil
def to_u8 : UInt8
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_chr : Char
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int32) : self
def unsafe_div(other : Int64) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt8) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt64) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int32) : self
def unsafe_mod(other : Int64) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt8) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt64) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int32) : self
def unsafe_shl(other : Int64) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt8) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt64) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int32) : self
def unsafe_shr(other : Int64) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt8) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt64) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i : Int32
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i32 : Int32
def unsafe_to_i64 : Int64
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def unsafe_to_u64 : UInt64
def unsafe_to_u8 : UInt8
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int32) : self
def |(other : Int64) : self
def |(other : Int128) : self
def |(other : UInt8) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt64) : self
def |(other : UInt128) : self
def ~ : UInt32
endUInt64struct, reopened
struct ::UInt64
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt128) : Bool
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int128) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int128) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int128) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int128) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int128) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt128) : self
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int128) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt128) : self
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int128) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt128) : self
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int128) : Bool
def <(other : UInt32) : Bool
def <(other : UInt128) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : UInt64
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt128) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int128) : Bool
def >(other : UInt32) : Bool
def >(other : UInt128) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt128) : Bool
def >>(count : Int32) : UInt64
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int128) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt128) : self
def abs : UInt64
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32? : Int32 | ::Nil
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64? : UInt64 | ::Nil
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int128) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt128) : self
def ~ : UInt64
endUInt8struct, reopened
struct ::UInt8
def !=(other : Int8) : Bool
def !=(other : Int16) : Bool
def !=(other : Int128) : Bool
def !=(other : UInt32) : Bool
def !=(other : UInt128) : Bool
def %(other : UInt8) : UInt8
def &(other : Int8) : self
def &(other : Int16) : self
def &(other : Int128) : self
def &(other : UInt16) : self
def &(other : UInt32) : self
def &(other : UInt128) : self
def &*(other : Int8) : self
def &*(other : Int16) : self
def &*(other : Int128) : self
def &*(other : UInt16) : self
def &*(other : UInt32) : self
def &*(other : UInt128) : self
def &+(other : Int8) : self
def &+(other : Int16) : self
def &+(other : Int128) : self
def &+(other : UInt16) : self
def &+(other : UInt32) : self
def &+(other : UInt128) : self
def &-(other : Int8) : self
def &-(other : Int16) : self
def &-(other : Int128) : self
def &-(other : UInt16) : self
def &-(other : UInt32) : self
def &-(other : UInt128) : self
def *(other : Int8) : self
def *(other : Int16) : self
def *(other : Int128) : self
def *(other : UInt16) : self
def *(other : UInt32) : self
def *(other : UInt128) : self
def +(other : Int8) : self
def +(other : Int16) : self
def +(other : Int128) : self
def +(other : UInt16) : self
def +(other : UInt32) : self
def +(other : UInt128) : self
def -(other : Int8) : self
def -(other : Int16) : self
def -(other : Int128) : self
def -(other : UInt16) : self
def -(other : UInt32) : self
def -(other : UInt128) : self
# An integer divided by a float is a float, as the prelude has it for
# `Int32` and `Int64` - and for `UInt8` and `UInt64` too, which the
# prelude does not write: `x / 3.0` did not type for them, and with a
# literal divisor the `Float32` overload took it, so `1_u8 / 3.0` was a
# single, 0.33333334.
def /(other : Float64) : Float64
# The zero is checked here rather than left to the processor, which
# reports an integer division by zero as a floating-point fault.
def //(other : UInt8) : UInt8
def <(other : Int8) : Bool
def <(other : Int16) : Bool
def <(other : Int128) : Bool
def <(other : UInt32) : Bool
def <(other : UInt128) : Bool
# A shift by the width or more answers zero (or the sign, shifting a
# negative value right), which the processor does not promise, and a
# negative count shifts the other way, as the prelude's `Int32` does.
def <<(count : Int32) : UInt8
def <=(other : Int8) : Bool
def <=(other : Int16) : Bool
def <=(other : Int128) : Bool
def <=(other : UInt32) : Bool
def <=(other : UInt128) : Bool
# Exact for every width: the double is placed against the type's
# edges, then its floor - one of the type, once inside them - against
# the value, then its fraction decides a tie. NaN is after every
# number, as `Float64#<=>` places it. The prelude's `Int64 == Float64`
# is exact too, and agrees with this on every number.
def <=>(other : Float64) : Int32
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int8) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int16) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : Int128) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt32) : Bool
# The prelude compares six types and adds five: `UInt16` is in its
# comparison cross (a wide character is compared against a
# separator on every Windows path) and not in its arithmetic one,
# so the comparisons for a pair it already declares are skipped
# here and the arithmetic below is not. Redefining a prelude
# method is refused by name (SPEC.md R-3), which is how the split
# announced itself.
def ==(other : UInt128) : Bool
def >(other : Int8) : Bool
def >(other : Int16) : Bool
def >(other : Int128) : Bool
def >(other : UInt32) : Bool
def >(other : UInt128) : Bool
def >=(other : Int8) : Bool
def >=(other : Int16) : Bool
def >=(other : Int128) : Bool
def >=(other : UInt32) : Bool
def >=(other : UInt128) : Bool
def >>(count : Int32) : UInt8
def ^(other : Int8) : self
def ^(other : Int16) : self
def ^(other : Int128) : self
def ^(other : UInt16) : self
def ^(other : UInt32) : self
def ^(other : UInt128) : self
def abs : UInt8
# Bits needed to write the value, the sign excluded: `255.bit_length`
# is 8, `(-1).bit_length` is 0 and `(-2).bit_length` is 1.
def bit_length : Int32
def leading_zeros_count : Int32
# --- the bits, counted with a logical shift for every type ----------
# A negative value has its sign bits counted: `(-1).popcount` is 32,
# one loop of the type's width.
def popcount : Int32
def to_i128 : Int128
def to_i128? : Int128 | ::Nil
def to_i16 : Int16
def to_i16? : Int16 | ::Nil
def to_i32? : Int32 | ::Nil
def to_i64? : Int64 | ::Nil
# Conversions: the checked form panics "arithmetic overflow" when the
# value does not fit; the `?` form answers nil instead; the unchecked
# form is the instruction - truncated, or extended by the sign of the
# type it leaves - as the prelude's `unsafe_to_u8` is. A pair the
# prelude already declares is not declared twice.
def to_i8 : Int8
def to_i8? : Int8 | ::Nil
def to_i? : Int32 | ::Nil
def to_u : UInt32
def to_u128 : UInt128
def to_u128? : UInt128 | ::Nil
def to_u16 : UInt16
def to_u16? : UInt16 | ::Nil
def to_u32 : UInt32
def to_u32? : UInt32 | ::Nil
def to_u64? : UInt64 | ::Nil
def to_u8? : UInt8 | ::Nil
def to_u? : UInt32 | ::Nil
def trailing_zeros_count : Int32
def unsafe_div(other : Int8) : self
def unsafe_div(other : Int16) : self
def unsafe_div(other : Int128) : self
def unsafe_div(other : UInt16) : self
def unsafe_div(other : UInt32) : self
def unsafe_div(other : UInt128) : self
def unsafe_mod(other : Int8) : self
def unsafe_mod(other : Int16) : self
def unsafe_mod(other : Int128) : self
def unsafe_mod(other : UInt16) : self
def unsafe_mod(other : UInt32) : self
def unsafe_mod(other : UInt128) : self
def unsafe_shl(other : Int8) : self
def unsafe_shl(other : Int16) : self
def unsafe_shl(other : Int128) : self
def unsafe_shl(other : UInt16) : self
def unsafe_shl(other : UInt32) : self
def unsafe_shl(other : UInt128) : self
def unsafe_shr(other : Int8) : self
def unsafe_shr(other : Int16) : self
def unsafe_shr(other : Int128) : self
def unsafe_shr(other : UInt16) : self
def unsafe_shr(other : UInt32) : self
def unsafe_shr(other : UInt128) : self
def unsafe_to_i128 : Int128
def unsafe_to_i16 : Int16
def unsafe_to_i8 : Int8
def unsafe_to_u : UInt32
def unsafe_to_u128 : UInt128
def unsafe_to_u16 : UInt16
def unsafe_to_u32 : UInt32
def |(other : Int8) : self
def |(other : Int16) : self
def |(other : Int128) : self
def |(other : UInt16) : self
def |(other : UInt32) : self
def |(other : UInt128) : self
def ~ : UInt8
end
The whole integer tower:
Int8,Int16,UInt16,UInt32,Int128andUInt128made as usable as the prelude'sInt32,Int64,UInt8andUInt64.