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 \\ | & ‘ noexn ’ & \Rightarrow & noexn \\ | & ‘ exn ’ & \Rightarrow & exn \\ | & ‘ 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 ’ ‘) ’ \\ ‘ exnref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ exn ’ ‘) ’ \\ ‘ nullexnref ’ & \equiv & ‘ (’ ‘ ref ’ ‘ null ’ ‘ noexn ’ ‘) ’ \\ ‘ 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} {comptype}_{I} & ::= & ‘ (’ ‘ struct ’ {ft}^{*} : list ({field}_{I}) ‘) ’ & \Rightarrow & struct {ft}^{*} \\ | & ‘ (’ ‘ array ’ ft : {fieldtype}_{I} ‘) ’ & \Rightarrow & array ft \\ | & ‘ (’ ‘ func ’ t_{1}^{*} : list ({param}_{I}) t_{2}^{*} : list ({result}_{I}) ‘) ’ & \Rightarrow & func [t_{1}^{*}] \to [t_{2}^{*}] \\ {param}_{I} & ::= & ‘ (’ ‘ param ’ {id}^{?} t : {valtype}_{I} ‘) ’ & \Rightarrow & t \\ {result}_{I} & ::= & ‘ (’ ‘ result ’ t : {valtype}_{I} ‘) ’ & \Rightarrow & t \\ {field}_{I} & ::= & ‘ (’ ‘ field ’ {id}^{?} ft : {fieldtype}_{I} ‘) ’ & \Rightarrow & ft \\ {fieldtype}_{I} & ::= & st : storagetype & \Rightarrow & st \\ | & ‘ (’ ‘ mut ’ st : storagetype ‘) ’ & \Rightarrow & mut st \\ {storagetype}_{I} & ::= & t : {valtype}_{I} & \Rightarrow & t \\ | & t : packtype & \Rightarrow & t \\ packtype & ::= & ‘ i 8 ’ & \Rightarrow & i 8 \\ | & ‘ i 16 ’ & \Rightarrow & i 16 \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}

Similarly, 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} {rectype}_{I} & ::= & ‘ (’ ‘ rec ’ {st}^{*} : list ({typedef}_{I}) ‘) ’ & \Rightarrow & rec {st}^{*} \\ {typedef}_{I} & ::= & ‘ (’ ‘ type ’ {id}^{?} st : {subtype}_{I} ‘) ’ & \Rightarrow & st \\ {subtype}_{I} & ::= & ‘ (’ ‘ sub ’ ‘ final ’^{?} x^{*} : list ({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} addrtype & ::= & ‘ i 32 ’ & \Rightarrow & i 32 \\ | & ‘ i 64 ’ & \Rightarrow & i 64 \end{array} \end{array}

The address type can be omitted, in which case it defaults $i 32$ :

\begin{array}{llclll} ‘ ’ & \equiv & ‘ i 32 ’ \end{array}

\begin{array}{r} \begin{array}{llclll} {limits}_{N} & ::= & n : u 64 & \Rightarrow & [n . . 2^{N}] \\ | & n : u 64 m : u 64 & \Rightarrow & [n . . m] \end{array} \end{array}

\begin{array}{r} \begin{array}{llcl} {tagtype}_{I} & ::= & x, I^{'} : {typeuse}_{I} \Rightarrow x \end{array} \end{array}

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

\begin{array}{r} \begin{array}{llcllll} {memtype}_{I} & ::= & at : addrtype \lim : {limits}_{| at | / 64 \cdot Ki} & \Rightarrow & at \lim page \end{array} \end{array}

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

\begin{array}{r} \begin{array}{llclll} {externtype}_{I} & ::= & ‘ (’ ‘ tag ’ {id}^{?} tt : tagtype ‘) ’ & \Rightarrow & tag tt \\ | & ‘ (’ ‘ global ’ {id}^{?} gt : {globaltype}_{I} ‘) ’ & \Rightarrow & global gt \\ | & ‘ (’ ‘ memory ’ {id}^{?} mt : {memtype}_{I} ‘) ’ & \Rightarrow & mem mt \\ | & ‘ (’ ‘ table ’ {id}^{?} tt : {tabletype}_{I} ‘) ’ & \Rightarrow & table tt \\ | & ‘ (’ ‘ func ’ {id}^{?} x, I^{'} : {typeuse}_{I} ‘) ’ & \Rightarrow & func x \end{array} \end{array}