🥮 mooncakes.io

    marianoguerra/wax/wasm/types does not have a README file

    FieldType

    source
    type FieldType[Idx] = MutType[StorageType[Idx]]

    A struct field or array element type.

    GlobalType

    source
    type GlobalType[Idx] = MutType[ValType[Idx]]

    A global's type.

    AddressType

    source
    pub(all) enum AddressType {
      I32
      I64
    } derive(Eq, 
    Debug    )

    Whether a memory or table is indexed by i32 or i64 (memory64).

    CmpOp

    source
    pub(all) enum CmpOp {
      Eq
      Ne
      Lt
      Gt
      Le
      Ge
    } derive(Eq, 
    Debug    )

    Comparison operators available inside a conditional-compilation condition.

    Cond

    source

    A conditional-compilation condition, from #[if(...)].

    Evaluated against the -D variables, not against program values: it decides which source survives, so it belongs to the type layer rather than the instruction layer.

    HeapType

    source
    pub(all) enum HeapType[Idx] {
      Func
      NoFunc
      Exn
      NoExn
      Cont
      NoCont
      Extern
      NoExtern
      Any
      Eq
      I31
      Struct
      Array
      None_
      Type(Idx)
      Exact(Idx)
    } derive(Eq, Hash, 
    Debug    )

    A heap type: what a reference can point at.

    The No* cases are the bottom types of each hierarchy (nofunc is a subtype of every function type and has no values), and None_ is the bottom of the internal hierarchy. Type names a concrete defined type; Exact names one and forbids subtypes, which is the custom-descriptors proposal's &!t.

    HeapType::keyword

    source
    fn[Idx] HeapType::keyword(self : HeapType[Idx]) -> String?

    The keyword naming a heap type, or None for the two that carry an index.

    The index-carrying cases have no keyword because each printer spells the index its own way -- by name in Wax, by number in the binary form.

    Limits

    source
    pub(all) struct Limits {
      mi : UInt64
      ma : UInt64?
      address_type : AddressType
      page_size_log2 : Int?
      shared : Bool
    } derive(Eq, 
    Debug    )

    The size bounds of a memory or table.

    page_size_log2 is the base-2 logarithm of a custom page size (the custom-page-sizes proposal); None means the default 65536. It is stored as the logarithm rather than the size because that is what the binary format encodes, so round-tripping cannot lose a non-power-of-two spelling.

    mi/ma are u64 to cover 64-bit memories. MoonBit's UInt64 is used directly where the reference has its own Uint64 module.

    MutType

    source
    pub(all) struct MutType[T] {
      mut_ : Bool
      typ : T
    } derive(Eq, Hash, 
    Debug    )

    A type paired with its mutability. Used for both globals and struct fields, which is why it is generic in the thing being made mutable.

    PackedType

    source
    pub(all) enum PackedType {
      I8
      I16
    } derive(Eq, Hash, 
    Debug    )

    A packed storage type. These exist only in struct fields and arrays: there is no i8 or i16 on the operand stack, so they are not value types.

    RefType

    source
    pub(all) struct RefType[Idx] {
      nullable : Bool
      typ : HeapType[Idx]
    } derive(Eq, Hash, 
    Debug    )

    A reference type: a heap type plus whether null is allowed.

    Signage

    source
    pub(all) enum Signage {
      Signed
      Unsigned
    } derive(Eq, 
    Debug    )

    Signedness, where WebAssembly needs an operation to state it.

    StorageType

    source
    pub(all) enum StorageType[Idx] {
      Value(ValType[Idx])
      Packed(PackedType)
    } derive(Eq, Hash, 
    Debug    )

    What a struct field or array element stores.

    V128

    source
    pub(all) struct V128 {
      shape : V128Shape
      components : Array[String]
    } derive(Eq, 
    Debug    )

    A 128-bit vector literal, kept as its shape plus the raw component strings.

    The components stay unparsed for the same reason numeric literals do: the printer has to reproduce what was written, and a v128 can be spelled in six different shapes.

    V128Shape

    source
    pub(all) enum V128Shape {
      I8x16
      I16x8
      I32x4
      I64x2
      F32x4
      F64x2
    } derive(Eq, 
    Debug    )

    V128Shape::to_str

    source
    fn V128Shape::to_str(self : V128Shape) -> String

    ValType

    source
    pub(all) enum ValType[Idx] {
      I32
      I64
      F32
      F64
      V128
      Ref(RefType[Idx])
    } derive(Eq, Hash, 
    Debug    )

    A value type -- what a local, parameter or stack slot holds.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io