Language.Wasm.Builder

Documentation

type GenMod = State GenModState

genMod :: GenMod a -> Module

global :: ValueTypeable t => (ValueType -> GlobalType) -> Proxy t -> ValType t -> GenMod (Glob t)

typedef :: Returnable res => res -> [ValueType] -> GenMod (TypeDef res)

fun :: Returnable res => res -> GenFun res -> GenMod (Fn res)

funRec :: Returnable res => res -> (Fn res -> GenFun res) -> GenMod (Fn res)

declare :: Returnable res => res -> [ValueType] -> GenMod (Fn res)

implement :: Returnable res => Fn res -> GenFun res -> GenMod (Fn res)

table :: Natural -> Maybe Natural -> GenMod Tbl

memory :: Natural -> Maybe Natural -> GenMod Mem

dataSegment :: (Producer offset, OutType offset ~ Proxy I32) => offset -> ByteString -> GenMod ()

importFunction :: Returnable res => Text -> Text -> res -> [ValueType] -> GenMod (Fn res)

importGlobal :: ValueTypeable t => Text -> Text -> Proxy t -> GenMod (Glob t)

importMemory :: Text -> Text -> Natural -> Maybe Natural -> GenMod Mem

importTable :: Text -> Text -> Natural -> Maybe Natural -> GenMod Tbl

export :: Exportable e => Text -> e -> GenMod (AfterExport e)

nextFuncIndex :: GenMod Natural

setGlobalInitializer :: forall t. ValueTypeable t => Glob t -> ValType t -> GenMod ()

type GenFun = ReaderT Natural (State FuncDef)

data Glob t

Instances

Eq (Glob k t)

Methods

(==) :: Glob k t -> Glob k t -> Bool

(/=) :: Glob k t -> Glob k t -> Bool

Show (Glob k t)

Methods

showsPrec :: Int -> Glob k t -> ShowS

show :: Glob k t -> String

showList :: [Glob k t] -> ShowS

Consumer (Glob k t)

Methods

(.=) :: Producer expr => Glob k t -> expr -> GenFun ()

ValueTypeable k t => Producer (Glob k t)

Associated Types

type OutType (Glob k t) :: *

Methods

asTypedExpr :: Glob k t -> TypedExpr

asValueType :: Glob k t -> ValueType

produce :: Glob k t -> GenFun (OutType (Glob k t))

type OutType (Glob k t)

type OutType (Glob k t) = Proxy k t

data Loc t

Instances

Eq (Loc k t)

Methods

(==) :: Loc k t -> Loc k t -> Bool

(/=) :: Loc k t -> Loc k t -> Bool

Show (Loc k t)

Methods

showsPrec :: Int -> Loc k t -> ShowS

show :: Loc k t -> String

showList :: [Loc k t] -> ShowS

Consumer (Loc k t)

Methods

(.=) :: Producer expr => Loc k t -> expr -> GenFun ()

ValueTypeable k t => Producer (Loc k t)

Associated Types

type OutType (Loc k t) :: *

Methods

asTypedExpr :: Loc k t -> TypedExpr

asValueType :: Loc k t -> ValueType

produce :: Loc k t -> GenFun (OutType (Loc k t))

type OutType (Loc k t)

type OutType (Loc k t) = Proxy k t

newtype Fn a

Constructors

Fn Natural

Instances

Eq (Fn k a)

Methods

(==) :: Fn k a -> Fn k a -> Bool

(/=) :: Fn k a -> Fn k a -> Bool

Show (Fn k a)

Methods

showsPrec :: Int -> Fn k a -> ShowS

show :: Fn k a -> String

showList :: [Fn k a] -> ShowS

data Mem

Instances

Eq Mem

Methods

(==) :: Mem -> Mem -> Bool

(/=) :: Mem -> Mem -> Bool

Show Mem

Methods

showsPrec :: Int -> Mem -> ShowS

show :: Mem -> String

showList :: [Mem] -> ShowS

data Tbl

Instances

Eq Tbl

Methods

(==) :: Tbl -> Tbl -> Bool

(/=) :: Tbl -> Tbl -> Bool

Show Tbl

Methods

showsPrec :: Int -> Tbl -> ShowS

show :: Tbl -> String

showList :: [Tbl] -> ShowS

data Label i

Instances

Eq (Label k i)

Methods

(==) :: Label k i -> Label k i -> Bool

(/=) :: Label k i -> Label k i -> Bool

Show (Label k i)

Methods

showsPrec :: Int -> Label k i -> ShowS

show :: Label k i -> String

showList :: [Label k i] -> ShowS

param :: ValueTypeable t => Proxy t -> GenFun (Loc t)

local :: ValueTypeable t => Proxy t -> GenFun (Loc t)

label :: GenFun (Label t)

ret :: Producer expr => expr -> GenFun (OutType expr)

arg :: Producer expr => expr -> GenFun ()

i32 :: Proxy ValueType I32

i64 :: Proxy ValueType I64

f32 :: Proxy ValueType F32

f64 :: Proxy ValueType F64

i32c :: Integral i => i -> GenFun (Proxy I32)

i64c :: Integral i => i -> GenFun (Proxy I64)

f32c :: Float -> GenFun (Proxy F32)

f64c :: Double -> GenFun (Proxy F64)

add :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (OutType a)

inc :: (Consumer a, Producer a, Integral i) => i -> a -> GenFun ()

sub :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (OutType a)

dec :: (Consumer a, Producer a, Integral i) => i -> a -> GenFun ()

mul :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (OutType a)

div_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

div_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

rem_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

rem_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

and :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

or :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

xor :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

shl :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

shr_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

shr_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

rotl :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

rotr :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

clz :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (OutType a)

ctz :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (OutType a)

popcnt :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (OutType a)

eq :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (Proxy I32)

ne :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (Proxy I32)

lt_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

lt_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

gt_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

gt_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

le_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

le_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

ge_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

ge_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

eqz :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (Proxy I32)

div_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

min_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

max_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

copySign :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

abs_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

neg_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

ceil_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

floor_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

trunc_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

nearest_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

sqrt_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

lt_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

gt_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

le_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

ge_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

wrap :: (Producer i, OutType i ~ Proxy I64) => i -> GenFun (Proxy I32)

trunc_s :: (Producer f, IsFloat (OutType f) ~ True, IsInt (Proxy t) ~ True, ValueTypeable t) => Proxy t -> f -> GenFun (Proxy t)

trunc_u :: (Producer f, IsFloat (OutType f) ~ True, IsInt (Proxy t) ~ True, ValueTypeable t) => Proxy t -> f -> GenFun (Proxy t)

extend_s :: (Producer i, OutType i ~ Proxy I32) => i -> GenFun (Proxy I64)

extend_u :: (Producer i, OutType i ~ Proxy I32) => i -> GenFun (Proxy I64)

convert_s :: (Producer i, IsInt (OutType i) ~ True, IsFloat (Proxy t) ~ True, ValueTypeable t) => Proxy t -> i -> GenFun (Proxy t)

convert_u :: (Producer i, IsInt (OutType i) ~ True, IsFloat (Proxy t) ~ True, ValueTypeable t) => Proxy t -> i -> GenFun (Proxy t)

demote :: (Producer f, OutType f ~ Proxy F64) => f -> GenFun (Proxy F32)

promote :: (Producer f, OutType f ~ Proxy F32) => f -> GenFun (Proxy F64)

reinterpret :: (ValueTypeable t, Producer val, SameSize (Proxy t) (OutType val) ~ True) => Proxy t -> val -> GenFun (Proxy t)

load :: (ValueTypeable t, Producer addr, OutType addr ~ Proxy I32, Integral offset, Integral align) => Proxy t -> addr -> offset -> align -> GenFun (Proxy t)

load8_u :: (ValueTypeable t, IsInt (Proxy t) ~ True, Producer addr, OutType addr ~ Proxy I32, Integral offset, Integral align) => Proxy t -> addr -> offset -> align -> GenFun (Proxy t)

load8_s :: (ValueTypeable t, IsInt (Proxy t) ~ True, Producer addr, OutType addr ~ Proxy I32, Integral offset, Integral align) => Proxy t -> addr -> offset -> align -> GenFun (Proxy t)

load16_u :: (ValueTypeable t, IsInt (Proxy t) ~ True, Producer addr, OutType addr ~ Proxy I32, Integral offset, Integral align) => Proxy t -> addr -> offset -> align -> GenFun (Proxy t)

load16_s :: (ValueTypeable t, IsInt (Proxy t) ~ True, Producer addr, OutType addr ~ Proxy I32, Integral offset, Integral align) => Proxy t -> addr -> offset -> align -> GenFun (Proxy t)

load32_u :: (ValueTypeable t, IsInt (Proxy t) ~ True, Producer addr, OutType addr ~ Proxy I32, Integral offset, Integral align) => Proxy t -> addr -> offset -> align -> GenFun (Proxy t)

load32_s :: (ValueTypeable t, IsInt (Proxy t) ~ True, Producer addr, OutType addr ~ Proxy I32, Integral offset, Integral align) => Proxy t -> addr -> offset -> align -> GenFun (Proxy t)

store :: (Producer addr, OutType addr ~ Proxy I32, Producer val, Integral offset, Integral align) => addr -> val -> offset -> align -> GenFun ()

store8 :: (Producer addr, OutType addr ~ Proxy I32, Producer val, IsInt (OutType val) ~ True, Integral offset, Integral align) => addr -> val -> offset -> align -> GenFun ()

store16 :: (Producer addr, OutType addr ~ Proxy I32, Producer val, IsInt (OutType val) ~ True, Integral offset, Integral align) => addr -> val -> offset -> align -> GenFun ()

store32 :: (Producer addr, OutType addr ~ Proxy I32, Producer val, OutType val ~ Proxy I64, Integral offset, Integral align) => addr -> val -> offset -> align -> GenFun ()

memorySize :: GenFun (Proxy I32)

growMemory :: (Producer size, OutType size ~ Proxy I32) => size -> GenFun ()

nop :: GenFun ()

drop :: Producer val => val -> GenFun ()

select :: (Producer a, Producer b, OutType a ~ OutType b, Producer pred, OutType pred ~ Proxy I32) => pred -> a -> b -> GenFun (OutType a)

call :: Returnable res => Fn res -> [GenFun a] -> GenFun res

callIndirect :: (Producer index, OutType index ~ Proxy I32, Returnable res) => TypeDef res -> index -> [GenFun a] -> GenFun res

finish :: Producer val => val -> GenFun ()

br :: Label t -> GenFun ()

brIf :: (Producer pred, OutType pred ~ Proxy I32) => pred -> Label t -> GenFun ()

brTable :: (Producer selector, OutType selector ~ Proxy I32) => selector -> [Label t] -> Label t -> GenFun ()

if' :: (Producer pred, OutType pred ~ Proxy I32, Returnable res) => res -> pred -> GenFun res -> GenFun res -> GenFun res

loop :: Returnable res => res -> GenFun res -> GenFun res

block :: Returnable res => res -> GenFun res -> GenFun res

when :: (Producer pred, OutType pred ~ Proxy I32) => pred -> GenFun () -> GenFun ()

for :: (Producer pred, OutType pred ~ Proxy I32) => GenFun () -> pred -> GenFun () -> GenFun () -> GenFun ()

while :: (Producer pred, OutType pred ~ Proxy I32) => pred -> GenFun () -> GenFun ()

trap :: Proxy t -> GenFun (Proxy t)

unreachable :: GenFun ()

appendExpr :: Expression -> GenFun ()

after :: Expression -> GenFun a -> GenFun a

class Producer expr where

Minimal complete definition

asTypedExpr, asValueType, produce

Associated Types

type OutType expr

Methods

produce :: expr -> GenFun (OutType expr)

Instances

ValueTypeable k t => Producer (GenFun (Proxy k t))

Associated Types

type OutType (GenFun (Proxy k t)) :: *

Methods

asTypedExpr :: GenFun (Proxy k t) -> TypedExpr

asValueType :: GenFun (Proxy k t) -> ValueType

produce :: GenFun (Proxy k t) -> GenFun (OutType (GenFun (Proxy k t)))

ValueTypeable k t => Producer (Glob k t)

Associated Types

type OutType (Glob k t) :: *

Methods

asTypedExpr :: Glob k t -> TypedExpr

asValueType :: Glob k t -> ValueType

produce :: Glob k t -> GenFun (OutType (Glob k t))

ValueTypeable k t => Producer (Loc k t)

Associated Types

type OutType (Loc k t) :: *

Methods

asTypedExpr :: Loc k t -> TypedExpr

asValueType :: Loc k t -> ValueType

produce :: Loc k t -> GenFun (OutType (Loc k t))

produce :: Producer expr => expr -> GenFun (OutType expr)

class Consumer loc where

Minimal complete definition

(.=)

Methods

(.=) :: Producer expr => loc -> expr -> GenFun () infixr 2

Instances

Consumer (Glob k t)

Methods

(.=) :: Producer expr => Glob k t -> expr -> GenFun ()

Consumer (Loc k t)

Methods

(.=) :: Producer expr => Loc k t -> expr -> GenFun ()

(.=) :: (Consumer loc, Producer expr) => loc -> expr -> GenFun () infixr 2