Types¶

Number Types¶

\begin{array}{r} \begin{array}{llrlll} {numtype}_{I} & ::= & ‘ i 32 ’ & \Rightarrow & i 32 \\ | & ‘ i 64 ’ & \Rightarrow & i 64 \\ | & ‘ f 32 ’ & \Rightarrow & f 32 \\ | & ‘ f 64 ’ & \Rightarrow & f 64 \end{array} \end{array}

\begin{array}{r} \begin{array}{llclll} {vectype}_{I} & ::= & ‘ v 128 ’ & \Rightarrow & v 128 \end{array} \end{array}

\begin{array}{r} \begin{array}{llrlll} absheaptype & ::= & ‘ any ’ & \Rightarrow & any \\ | & ‘ eq ’ & \Rightarrow & eq \\ | & ‘ i 31 ’ & \Rightarrow & i 31 \\ | & ‘ struct ’ & \Rightarrow & struct \\ | & ‘ array ’ & \Rightarrow & array \\ | & ‘ none ’ & \Rightarrow & none \\ | & ‘ func ’ & \Rightarrow & func \\ | & ‘ nofunc ’ & \Rightarrow & nofunc \\ | & ‘ extern ’ & \Rightarrow & extern \\ | & ‘ noextern ’ & \Rightarrow & noextern \\ {heaptype}_{I} & ::= & t : absheaptype & \Rightarrow & y \\ | & x : {typeidx}_{I} & \Rightarrow & x \end{array} \end{array}

\begin{array}{r} \begin{array}{llclll} {reftype}_{I} & ::= & ‘ (’ ‘ ref ’ ht : heaptype ‘) ’ & \Rightarrow & ref ht \\ | & ‘ (’ ‘ ref ’ ‘ null ’ ht : heaptype ‘) ’ & \Rightarrow & ref null ht \end{array} \end{array}

There are shorthands for references to abstract heap types.

\begin{array}{r} \begin{array}{llclll} ‘ anyref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ any ’ ‘) ’ \\ ‘ eqref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ eq ’ ‘) ’ \\ ‘ i 31 ref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ i 31 ’ ‘) ’ \\ ‘ structref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ struct ’ ‘) ’ \\ ‘ arrayref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ array ’ ‘) ’ \\ ‘ nullref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ none ’ ‘) ’ \\ ‘ funcref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ func ’ ‘) ’ \\ ‘ nullfuncref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ nofunc ’ ‘) ’ \\ ‘ externref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ extern ’ ‘) ’ \\ ‘ nullexternref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ noextern ’ ‘) ’ \end{array} \end{array}

\begin{array}{r} \begin{array}{llclll} {valtype}_{I} & ::= & t : {numtype}_{I} & \Rightarrow & t \\ | & t : {vectype}_{I} & \Rightarrow & t \\ | & t : {reftype}_{I} & \Rightarrow & t \end{array} \end{array}

\begin{array}{r} \begin{array}{llcllll} {functype}_{I} & ::= & ‘ (’ ‘ func ’ t_{1}^{*} : vec ({param}_{I}) t_{2}^{*} : vec ({result}_{I}) ‘) ’ & \Rightarrow & [t_{1}^{*}] \to [t_{2}^{*}] \\ {param}_{I} & ::= & ‘ (’ ‘ param ’ {id}^{?} t : {valtype}_{I} ‘) ’ & \Rightarrow & t \\ {result}_{I} & ::= & ‘ (’ ‘ result ’ t : {valtype}_{I} ‘) ’ & \Rightarrow & t \end{array} \end{array}

Note

The optional identifier names for parameters in a function type only have documentation purpose. They cannot be referenced from anywhere.

Multiple anonymous parameters or results may be combined into a single declaration:

\begin{array}{r} \begin{array}{llclll} ‘ (’ ‘ param ’ {valtype}^{*} ‘) ’ & \equiv & (‘ (’ ‘ param ’ valtype ‘) ’)^{*} \\ ‘ (’ ‘ result ’ {valtype}^{*} ‘) ’ & \equiv & (‘ (’ ‘ result ’ valtype ‘) ’)^{*} \end{array} \end{array}

\begin{array}{r} \begin{array}{llcllll} {arraytype}_{I} & ::= & ‘ (’ ‘ array ’ ft : {fieldtype}_{I} ‘) ’ & \Rightarrow & ft \\ {structtype}_{I} & ::= & ‘ (’ ‘ struct ’ {ft}^{*} : vec ({field}_{I}) ‘) ’ & \Rightarrow & {ft}^{*} \\ {field}_{I} & ::= & ‘ (’ ‘ field ’ {id}^{?} ft : {fieldtype}_{I} ‘) ’ & \Rightarrow & ft \\ {fieldtype}_{I} & ::= & st : storagetype & \Rightarrow & const st \\ | & ‘ (’ ‘ mut ’ st : storagetype ‘) ’ & \Rightarrow & var st \\ {storagetype}_{I} & ::= & t : {valtype}_{I} & \Rightarrow & t \\ | & t : packedtype & \Rightarrow & t \\ packedtype & ::= & ‘ i 8 ’ & \Rightarrow & i 8 \\ | & ‘ i 16 ’ & \Rightarrow & i 16 \end{array} \end{array}

Multiple anonymous structure fields may be combined into a single declaration:

\begin{array}{r} \begin{array}{llclll} ‘ (’ ‘ field ’ {fieldtype}^{*} ‘) ’ & \equiv & (‘ (’ ‘ field ’ fieldtype ‘) ’)^{*} \end{array} \end{array}

\begin{array}{r} \begin{array}{llcllll} {comptype}_{I} & ::= & at : {arraytype}_{I} & \Rightarrow & array at \\ | & st : {structtype}_{I} & \Rightarrow & struct at \\ | & ft : {functype}_{I} & \Rightarrow & func ft \end{array} \end{array}

\begin{array}{r} \begin{array}{llcllll} {rectype}_{I} & ::= & ‘ (’ ‘ rec ’ {st}^{*} : vec ({typedef}_{I}) ‘) ’ & \Rightarrow & rec {st}^{*} \\ {typedef}_{I} & ::= & ‘ (’ ‘ type ’ {id}^{?} st : {subtype}_{I} ‘) ’ & \Rightarrow & st \\ {subtype}_{I} & ::= & ‘ (’ ‘ sub ’ ‘ final ’^{?} x^{*} : vec ({typeidx}_{I}) ct : {comptype}_{I} ‘) ’ & \Rightarrow & sub {final}^{?} x^{*} ct \end{array} \end{array}

Singular recursive types can omit the $‘ rec ’$ keyword:

\begin{array}{r} \begin{array}{llclll} typedef & \equiv & ‘ (’ ‘ rec ’ typedef ‘) ’ \end{array} \end{array}

Similarly, final sub types with no super-types can omit the $sub$ keyword and arguments:

\begin{array}{r} \begin{array}{llclll} comptype & \equiv & ‘ (’ ‘ sub ’ ‘ final ’ ϵ comptype ‘) ’ \end{array} \end{array}

\begin{array}{r} \begin{array}{llclll} limits & ::= & n : u 32 & \Rightarrow & {\min n, \max ϵ} \\ | & n : u 32 m : u 32 & \Rightarrow & {\min n, \max m} \end{array} \end{array}

\begin{array}{r} \begin{array}{llcllll} {memtype}_{I} & ::= & \lim : limits & \Rightarrow & \lim \end{array} \end{array}

\begin{array}{r} \begin{array}{llclll} {tabletype}_{I} & ::= & \lim : limits et : {reftype}_{I} & \Rightarrow & \lim et \end{array} \end{array}

\begin{array}{r} \begin{array}{llclll} {globaltype}_{I} & ::= & t : valtype & \Rightarrow & const t \\ | & ‘ (’ ‘ mut ’ t : {valtype}_{I} ‘) ’ & \Rightarrow & var t \end{array} \end{array}