wasm 1.1.0 → 1.1.1

raw patch · 1 files changed

+6/−6 lines, 1 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

+ Language.Wasm.Binary: decodeModule :: ByteString -> Either String Module

+ Language.Wasm.Binary: decodeModuleLazy :: ByteString -> Either String Module

+ Language.Wasm.Binary: dumpModule :: Module -> ByteString

+ Language.Wasm.Binary: dumpModuleLazy :: Module -> ByteString

+ Language.Wasm.Binary: instance Data.Serialize.Serialize (Language.Wasm.Structure.Instruction GHC.Natural.Natural)

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Binary.Index

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Binary.LocalTypeRange

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Binary.SectionType

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.DataSegment

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.ElemSegment

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.ElemType

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Export

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.ExportDesc

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.FuncType

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Function

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Global

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.GlobalType

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Import

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.ImportDesc

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Limit

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.MemArg

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Memory

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Module

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.Table

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.TableType

+ Language.Wasm.Binary: instance Data.Serialize.Serialize Language.Wasm.Structure.ValueType

+ Language.Wasm.Binary: instance GHC.Classes.Eq Language.Wasm.Binary.Index

+ Language.Wasm.Binary: instance GHC.Classes.Eq Language.Wasm.Binary.LocalTypeRange

+ Language.Wasm.Binary: instance GHC.Classes.Eq Language.Wasm.Binary.SectionType

+ Language.Wasm.Binary: instance GHC.Enum.Enum Language.Wasm.Binary.SectionType

+ Language.Wasm.Binary: instance GHC.Show.Show Language.Wasm.Binary.Index

+ Language.Wasm.Binary: instance GHC.Show.Show Language.Wasm.Binary.LocalTypeRange

+ Language.Wasm.Binary: instance GHC.Show.Show Language.Wasm.Binary.SectionType

+ Language.Wasm.Builder: (.=) :: (Consumer loc, Producer expr) => loc -> expr -> GenFun ()

+ Language.Wasm.Builder: Fn :: Natural -> Fn a

+ Language.Wasm.Builder: abs_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: add :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: after :: Expression -> GenFun a -> GenFun a

+ Language.Wasm.Builder: and :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: appendExpr :: Expression -> GenFun ()

+ Language.Wasm.Builder: arg :: Producer expr => expr -> GenFun ()

+ Language.Wasm.Builder: br :: Label t -> GenFun ()

+ Language.Wasm.Builder: brIf :: (Producer pred, OutType pred ~ Proxy I32) => pred -> Label t -> GenFun ()

+ Language.Wasm.Builder: brTable :: (Producer selector, OutType selector ~ Proxy I32) => selector -> [Label t] -> Label t -> GenFun ()

+ Language.Wasm.Builder: call :: Returnable res => Fn res -> [GenFun a] -> GenFun res

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

+ Language.Wasm.Builder: ceil_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: class Consumer loc

+ Language.Wasm.Builder: class Producer expr

+ Language.Wasm.Builder: clz :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: convert_s :: (Producer i, IsInt (OutType i) ~ True, IsFloat (Proxy t) ~ True, ValueTypeable t) => Proxy t -> i -> GenFun (Proxy t)

+ Language.Wasm.Builder: convert_u :: (Producer i, IsInt (OutType i) ~ True, IsFloat (Proxy t) ~ True, ValueTypeable t) => Proxy t -> i -> GenFun (Proxy t)

+ Language.Wasm.Builder: copySign :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: ctz :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: data Glob t

+ Language.Wasm.Builder: data Label i

+ Language.Wasm.Builder: data Loc t

+ Language.Wasm.Builder: data Mem

+ Language.Wasm.Builder: data Tbl

+ Language.Wasm.Builder: dataSegment :: (Producer offset, OutType offset ~ Proxy I32) => offset -> ByteString -> GenMod ()

+ Language.Wasm.Builder: dec :: (Consumer a, Producer a, Integral i) => i -> a -> GenFun ()

+ Language.Wasm.Builder: declare :: Returnable res => res -> [ValueType] -> GenMod (Fn res)

+ Language.Wasm.Builder: demote :: (Producer f, OutType f ~ Proxy F64) => f -> GenFun (Proxy F32)

+ Language.Wasm.Builder: div_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: div_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: div_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: drop :: Producer val => val -> GenFun ()

+ Language.Wasm.Builder: eq :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: eqz :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (Proxy I32)

+ Language.Wasm.Builder: export :: Exportable e => Text -> e -> GenMod (AfterExport e)

+ Language.Wasm.Builder: extend_s :: (Producer i, OutType i ~ Proxy I32) => i -> GenFun (Proxy I64)

+ Language.Wasm.Builder: extend_u :: (Producer i, OutType i ~ Proxy I32) => i -> GenFun (Proxy I64)

+ Language.Wasm.Builder: f32 :: Proxy 'F32

+ Language.Wasm.Builder: f32c :: Float -> GenFun (Proxy F32)

+ Language.Wasm.Builder: f64 :: Proxy 'F64

+ Language.Wasm.Builder: f64c :: Double -> GenFun (Proxy F64)

+ Language.Wasm.Builder: finish :: Producer val => val -> GenFun ()

+ Language.Wasm.Builder: floor_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: fun :: Returnable res => res -> GenFun res -> GenMod (Fn res)

+ Language.Wasm.Builder: funRec :: Returnable res => res -> (Fn res -> GenFun res) -> GenMod (Fn res)

+ Language.Wasm.Builder: ge_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: ge_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: ge_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: genMod :: GenMod a -> Module

+ Language.Wasm.Builder: global :: ValueTypeable t => (ValueType -> GlobalType) -> Proxy t -> ValType t -> GenMod (Glob t)

+ Language.Wasm.Builder: growMemory :: (Producer size, OutType size ~ Proxy I32) => size -> GenFun ()

+ Language.Wasm.Builder: gt_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: gt_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: gt_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: i32 :: Proxy 'I32

+ Language.Wasm.Builder: i32c :: Integral i => i -> GenFun (Proxy I32)

+ Language.Wasm.Builder: i64 :: Proxy 'I64

+ Language.Wasm.Builder: i64c :: Integral i => i -> GenFun (Proxy I64)

+ Language.Wasm.Builder: implement :: Returnable res => Fn res -> GenFun res -> GenMod (Fn res)

+ Language.Wasm.Builder: importFunction :: Returnable res => Text -> Text -> res -> [ValueType] -> GenMod (Fn res)

+ Language.Wasm.Builder: importGlobal :: ValueTypeable t => Text -> Text -> Proxy t -> GenMod (Glob t)

+ Language.Wasm.Builder: importMemory :: Text -> Text -> Natural -> Maybe Natural -> GenMod Mem

+ Language.Wasm.Builder: importTable :: Text -> Text -> Natural -> Maybe Natural -> GenMod Tbl

+ Language.Wasm.Builder: inc :: (Consumer a, Producer a, Integral i) => i -> a -> GenFun ()

+ Language.Wasm.Builder: infixr 2 .=

+ Language.Wasm.Builder: instance GHC.Classes.Eq Language.Wasm.Builder.FuncDef

+ Language.Wasm.Builder: instance GHC.Classes.Eq Language.Wasm.Builder.GenModState

+ Language.Wasm.Builder: instance GHC.Classes.Eq Language.Wasm.Builder.Mem

+ Language.Wasm.Builder: instance GHC.Classes.Eq Language.Wasm.Builder.Tbl

+ Language.Wasm.Builder: instance GHC.Show.Show Language.Wasm.Builder.FuncDef

+ Language.Wasm.Builder: instance GHC.Show.Show Language.Wasm.Builder.GenModState

+ Language.Wasm.Builder: instance GHC.Show.Show Language.Wasm.Builder.Mem

+ Language.Wasm.Builder: instance GHC.Show.Show Language.Wasm.Builder.Tbl

+ Language.Wasm.Builder: instance Language.Wasm.Builder.Exportable Language.Wasm.Builder.Mem

+ Language.Wasm.Builder: instance Language.Wasm.Builder.Exportable Language.Wasm.Builder.Tbl

+ Language.Wasm.Builder: instance Language.Wasm.Builder.Exportable e => Language.Wasm.Builder.Exportable (Language.Wasm.Builder.GenMod e)

+ Language.Wasm.Builder: instance Language.Wasm.Builder.Returnable ()

+ Language.Wasm.Builder: instance Language.Wasm.Builder.ValueTypeable 'Language.Wasm.Structure.F32

+ Language.Wasm.Builder: instance Language.Wasm.Builder.ValueTypeable 'Language.Wasm.Structure.F64

+ Language.Wasm.Builder: instance Language.Wasm.Builder.ValueTypeable 'Language.Wasm.Structure.I32

+ Language.Wasm.Builder: instance Language.Wasm.Builder.ValueTypeable 'Language.Wasm.Structure.I64

+ Language.Wasm.Builder: instance forall k (a :: k). GHC.Classes.Eq (Language.Wasm.Builder.Fn a)

+ Language.Wasm.Builder: instance forall k (a :: k). GHC.Show.Show (Language.Wasm.Builder.Fn a)

+ Language.Wasm.Builder: instance forall k (i :: k). GHC.Classes.Eq (Language.Wasm.Builder.Label i)

+ Language.Wasm.Builder: instance forall k (i :: k). GHC.Show.Show (Language.Wasm.Builder.Label i)

+ Language.Wasm.Builder: instance forall k (t :: k). GHC.Classes.Eq (Language.Wasm.Builder.Glob t)

+ Language.Wasm.Builder: instance forall k (t :: k). GHC.Classes.Eq (Language.Wasm.Builder.Loc t)

+ Language.Wasm.Builder: instance forall k (t :: k). GHC.Classes.Eq (Language.Wasm.Builder.TypeDef t)

+ Language.Wasm.Builder: instance forall k (t :: k). GHC.Show.Show (Language.Wasm.Builder.Glob t)

+ Language.Wasm.Builder: instance forall k (t :: k). GHC.Show.Show (Language.Wasm.Builder.Loc t)

+ Language.Wasm.Builder: instance forall k (t :: k). GHC.Show.Show (Language.Wasm.Builder.TypeDef t)

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.Consumer (Language.Wasm.Builder.Glob t)

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.Consumer (Language.Wasm.Builder.Loc t)

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.Exportable (Language.Wasm.Builder.Fn t)

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.Exportable (Language.Wasm.Builder.Glob t)

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.ValueTypeable t => Language.Wasm.Builder.Producer (Language.Wasm.Builder.GenFun (Data.Proxy.Proxy t))

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.ValueTypeable t => Language.Wasm.Builder.Producer (Language.Wasm.Builder.Glob t)

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.ValueTypeable t => Language.Wasm.Builder.Producer (Language.Wasm.Builder.Loc t)

+ Language.Wasm.Builder: instance forall k (t :: k). Language.Wasm.Builder.ValueTypeable t => Language.Wasm.Builder.Returnable (Data.Proxy.Proxy t)

+ Language.Wasm.Builder: label :: GenFun (Label t)

+ Language.Wasm.Builder: le_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: le_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: le_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

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

+ Language.Wasm.Builder: 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)

+ Language.Wasm.Builder: 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)

+ Language.Wasm.Builder: 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)

+ Language.Wasm.Builder: 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)

+ Language.Wasm.Builder: 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)

+ Language.Wasm.Builder: 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)

+ Language.Wasm.Builder: local :: ValueTypeable t => Proxy t -> GenFun (Loc t)

+ Language.Wasm.Builder: lt_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: lt_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: lt_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: max_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: memory :: Natural -> Maybe Natural -> GenMod Mem

+ Language.Wasm.Builder: memorySize :: GenFun (Proxy I32)

+ Language.Wasm.Builder: min_f :: (Producer a, Producer b, OutType a ~ OutType b, IsFloat (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: mul :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: ne :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (Proxy I32)

+ Language.Wasm.Builder: nearest_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: neg_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: newtype Fn a

+ Language.Wasm.Builder: nextFuncIndex :: GenMod Natural

+ Language.Wasm.Builder: nop :: GenFun ()

+ Language.Wasm.Builder: or :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: param :: ValueTypeable t => Proxy t -> GenFun (Loc t)

+ Language.Wasm.Builder: popcnt :: (Producer a, IsInt (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: produce :: Producer expr => expr -> GenFun (OutType expr)

+ Language.Wasm.Builder: promote :: (Producer f, OutType f ~ Proxy F32) => f -> GenFun (Proxy F64)

+ Language.Wasm.Builder: reinterpret :: (ValueTypeable t, Producer val, SameSize (Proxy t) (OutType val) ~ True) => Proxy t -> val -> GenFun (Proxy t)

+ Language.Wasm.Builder: rem_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: rem_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: ret :: Producer expr => expr -> GenFun (OutType expr)

+ Language.Wasm.Builder: rotl :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: rotr :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: select :: (Producer a, Producer b, OutType a ~ OutType b, Producer pred, OutType pred ~ Proxy I32) => pred -> a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: setGlobalInitializer :: forall t. ValueTypeable t => Glob t -> ValType t -> GenMod ()

+ Language.Wasm.Builder: shl :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: shr_s :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: shr_u :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: sqrt_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: store :: (Producer addr, OutType addr ~ Proxy I32, Producer val, Integral offset, Integral align) => addr -> val -> offset -> align -> GenFun ()

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

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

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

+ Language.Wasm.Builder: sub :: (Producer a, Producer b, OutType a ~ OutType b) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Builder: table :: Natural -> Maybe Natural -> GenMod Tbl

+ Language.Wasm.Builder: trap :: Proxy t -> GenFun (Proxy t)

+ Language.Wasm.Builder: trunc_f :: (Producer a, IsFloat (OutType a) ~ True) => a -> GenFun (OutType a)

+ Language.Wasm.Builder: trunc_s :: (Producer f, IsFloat (OutType f) ~ True, IsInt (Proxy t) ~ True, ValueTypeable t) => Proxy t -> f -> GenFun (Proxy t)

+ Language.Wasm.Builder: trunc_u :: (Producer f, IsFloat (OutType f) ~ True, IsInt (Proxy t) ~ True, ValueTypeable t) => Proxy t -> f -> GenFun (Proxy t)

+ Language.Wasm.Builder: type GenFun = ReaderT Natural (State FuncDef)

+ Language.Wasm.Builder: type GenMod = State GenModState

+ Language.Wasm.Builder: type family OutType expr

+ Language.Wasm.Builder: typedef :: Returnable res => res -> [ValueType] -> GenMod (TypeDef res)

+ Language.Wasm.Builder: unreachable :: GenFun ()

+ Language.Wasm.Builder: wrap :: (Producer i, OutType i ~ Proxy I64) => i -> GenFun (Proxy I32)

+ Language.Wasm.Builder: xor :: (Producer a, Producer b, OutType a ~ OutType b, IsInt (OutType a) ~ True) => a -> b -> GenFun (OutType a)

+ Language.Wasm.Interpreter: ExportInstance :: Text -> ExternalValue -> ExportInstance

+ Language.Wasm.Interpreter: ExternFunction :: Address -> ExternalValue

+ Language.Wasm.Interpreter: ExternGlobal :: Address -> ExternalValue

+ Language.Wasm.Interpreter: ExternMemory :: Address -> ExternalValue

+ Language.Wasm.Interpreter: ExternTable :: Address -> ExternalValue

+ Language.Wasm.Interpreter: GIConst :: ValueType -> Value -> GlobalInstance

+ Language.Wasm.Interpreter: GIMut :: ValueType -> IORef Value -> GlobalInstance

+ Language.Wasm.Interpreter: HostFunction :: FuncType -> HostFunction -> HostItem

+ Language.Wasm.Interpreter: HostGlobal :: GlobalInstance -> HostItem

+ Language.Wasm.Interpreter: HostMemory :: Limit -> HostItem

+ Language.Wasm.Interpreter: HostTable :: Limit -> HostItem

+ Language.Wasm.Interpreter: ModuleInstance :: Vector FuncType -> Vector Address -> Vector Address -> Vector Address -> Vector Address -> Vector ExportInstance -> ModuleInstance

+ Language.Wasm.Interpreter: VF32 :: Float -> Value

+ Language.Wasm.Interpreter: VF64 :: Double -> Value

+ Language.Wasm.Interpreter: VI32 :: Word32 -> Value

+ Language.Wasm.Interpreter: VI64 :: Word64 -> Value

+ Language.Wasm.Interpreter: [$sel:exports:ModuleInstance] :: ModuleInstance -> Vector ExportInstance

+ Language.Wasm.Interpreter: [$sel:funcTypes:ModuleInstance] :: ModuleInstance -> Vector FuncType

+ Language.Wasm.Interpreter: [$sel:funcaddrs:ModuleInstance] :: ModuleInstance -> Vector Address

+ Language.Wasm.Interpreter: [$sel:globaladdrs:ModuleInstance] :: ModuleInstance -> Vector Address

+ Language.Wasm.Interpreter: [$sel:memaddrs:ModuleInstance] :: ModuleInstance -> Vector Address

+ Language.Wasm.Interpreter: [$sel:tableaddrs:ModuleInstance] :: ModuleInstance -> Vector Address

+ Language.Wasm.Interpreter: data ExportInstance

+ Language.Wasm.Interpreter: data ExternalValue

+ Language.Wasm.Interpreter: data GlobalInstance

+ Language.Wasm.Interpreter: data HostItem

+ Language.Wasm.Interpreter: data ModuleInstance

+ Language.Wasm.Interpreter: data Store

+ Language.Wasm.Interpreter: data Value

+ Language.Wasm.Interpreter: emptyImports :: Imports

+ Language.Wasm.Interpreter: emptyStore :: Store

+ Language.Wasm.Interpreter: getGlobalValueByName :: Store -> ModuleInstance -> Text -> IO Value

+ Language.Wasm.Interpreter: instance GHC.Classes.Eq Language.Wasm.Interpreter.EvalCtx

+ Language.Wasm.Interpreter: instance GHC.Classes.Eq Language.Wasm.Interpreter.EvalResult

+ Language.Wasm.Interpreter: instance GHC.Classes.Eq Language.Wasm.Interpreter.ExportInstance

+ Language.Wasm.Interpreter: instance GHC.Classes.Eq Language.Wasm.Interpreter.ExternalValue

+ Language.Wasm.Interpreter: instance GHC.Classes.Eq Language.Wasm.Interpreter.Label

+ Language.Wasm.Interpreter: instance GHC.Classes.Eq Language.Wasm.Interpreter.ModuleInstance

+ Language.Wasm.Interpreter: instance GHC.Classes.Eq Language.Wasm.Interpreter.Value

+ Language.Wasm.Interpreter: instance GHC.Show.Show Language.Wasm.Interpreter.EvalCtx

+ Language.Wasm.Interpreter: instance GHC.Show.Show Language.Wasm.Interpreter.EvalResult

+ Language.Wasm.Interpreter: instance GHC.Show.Show Language.Wasm.Interpreter.ExportInstance

+ Language.Wasm.Interpreter: instance GHC.Show.Show Language.Wasm.Interpreter.ExternalValue

+ Language.Wasm.Interpreter: instance GHC.Show.Show Language.Wasm.Interpreter.Label

+ Language.Wasm.Interpreter: instance GHC.Show.Show Language.Wasm.Interpreter.ModuleInstance

+ Language.Wasm.Interpreter: instance GHC.Show.Show Language.Wasm.Interpreter.Value

+ Language.Wasm.Interpreter: instantiate :: Store -> Imports -> ValidModule -> IO (Either String ModuleInstance, Store)

+ Language.Wasm.Interpreter: invoke :: Store -> Address -> [Value] -> IO (Maybe [Value])

+ Language.Wasm.Interpreter: invokeExport :: Store -> ModuleInstance -> Text -> [Value] -> IO (Maybe [Value])

+ Language.Wasm.Interpreter: makeConstGlobal :: Value -> GlobalInstance

+ Language.Wasm.Interpreter: makeHostModule :: Store -> [(Text, HostItem)] -> IO (Store, ModuleInstance)

+ Language.Wasm.Interpreter: makeMutGlobal :: Value -> IO GlobalInstance

+ Language.Wasm.Interpreter: type Imports = Map (Text, Text) ExternalValue

+ Language.Wasm.Parser: Action :: Action -> Command

+ Language.Wasm.Parser: AnonimousTypeUse :: FuncType -> TypeUse

+ Language.Wasm.Parser: AssertExhaustion :: Action -> FailureString -> Assertion

+ Language.Wasm.Parser: AssertInvalid :: ModuleDef -> FailureString -> Assertion

+ Language.Wasm.Parser: AssertMalformed :: ModuleDef -> FailureString -> Assertion

+ Language.Wasm.Parser: AssertReturn :: Action -> [Expression] -> Assertion

+ Language.Wasm.Parser: AssertReturnArithmeticNaN :: Action -> Assertion

+ Language.Wasm.Parser: AssertReturnCanonicalNaN :: Action -> Assertion

+ Language.Wasm.Parser: AssertTrap :: Either Action ModuleDef -> FailureString -> Assertion

+ Language.Wasm.Parser: AssertUnlinkable :: ModuleDef -> FailureString -> Assertion

+ Language.Wasm.Parser: Assertion :: Int -> Assertion -> Command

+ Language.Wasm.Parser: BinaryModDef :: Maybe Ident -> ByteString -> ModuleDef

+ Language.Wasm.Parser: BlockInstr :: Maybe Ident -> TypeUse -> [Instruction] -> Instruction

+ Language.Wasm.Parser: Br :: LabelIndex -> PlainInstr

+ Language.Wasm.Parser: BrIf :: LabelIndex -> PlainInstr

+ Language.Wasm.Parser: BrTable :: [LabelIndex] -> LabelIndex -> PlainInstr

+ Language.Wasm.Parser: Call :: FuncIndex -> PlainInstr

+ Language.Wasm.Parser: CallIndirect :: TypeUse -> PlainInstr

+ Language.Wasm.Parser: CurrentMemory :: PlainInstr

+ Language.Wasm.Parser: DataSegment :: MemoryIndex -> [Instruction] -> ByteString -> DataSegment

+ Language.Wasm.Parser: Drop :: PlainInstr

+ Language.Wasm.Parser: ElemSegment :: TableIndex -> [Instruction] -> [FuncIndex] -> ElemSegment

+ Language.Wasm.Parser: Export :: Text -> ExportDesc -> Export

+ Language.Wasm.Parser: ExportFunc :: FuncIndex -> ExportDesc

+ Language.Wasm.Parser: ExportGlobal :: GlobalIndex -> ExportDesc

+ Language.Wasm.Parser: ExportMemory :: MemoryIndex -> ExportDesc

+ Language.Wasm.Parser: ExportTable :: TableIndex -> ExportDesc

+ Language.Wasm.Parser: F32Const :: Float -> PlainInstr

+ Language.Wasm.Parser: F32DemoteF64 :: PlainInstr

+ Language.Wasm.Parser: F32Load :: MemArg -> PlainInstr

+ Language.Wasm.Parser: F32Store :: MemArg -> PlainInstr

+ Language.Wasm.Parser: F64Const :: Double -> PlainInstr

+ Language.Wasm.Parser: F64Load :: MemArg -> PlainInstr

+ Language.Wasm.Parser: F64PromoteF32 :: PlainInstr

+ Language.Wasm.Parser: F64Store :: MemArg -> PlainInstr

+ Language.Wasm.Parser: FBinOp :: BitSize -> FBinOp -> PlainInstr

+ Language.Wasm.Parser: FConvertIS :: BitSize -> BitSize -> PlainInstr

+ Language.Wasm.Parser: FConvertIU :: BitSize -> BitSize -> PlainInstr

+ Language.Wasm.Parser: FReinterpretI :: BitSize -> PlainInstr

+ Language.Wasm.Parser: FRelOp :: BitSize -> FRelOp -> PlainInstr

+ Language.Wasm.Parser: FUnOp :: BitSize -> FUnOp -> PlainInstr

+ Language.Wasm.Parser: FuncType :: [ParamType] -> [ValueType] -> FuncType

+ Language.Wasm.Parser: Function :: [Text] -> Maybe Ident -> TypeUse -> [LocalType] -> [Instruction] -> Function

+ Language.Wasm.Parser: Get :: Maybe Ident -> Text -> Action

+ Language.Wasm.Parser: GetGlobal :: GlobalIndex -> PlainInstr

+ Language.Wasm.Parser: GetLocal :: LocalIndex -> PlainInstr

+ Language.Wasm.Parser: Global :: [Text] -> Maybe Ident -> GlobalType -> [Instruction] -> Global

+ Language.Wasm.Parser: GrowMemory :: PlainInstr

+ Language.Wasm.Parser: I32Const :: Integer -> PlainInstr

+ Language.Wasm.Parser: I32Eqz :: PlainInstr

+ Language.Wasm.Parser: I32Load :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32Load16S :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32Load16U :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32Load8S :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32Load8U :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32Store :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32Store16 :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32Store8 :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I32WrapI64 :: PlainInstr

+ Language.Wasm.Parser: I64Const :: Integer -> PlainInstr

+ Language.Wasm.Parser: I64Eqz :: PlainInstr

+ Language.Wasm.Parser: I64ExtendSI32 :: PlainInstr

+ Language.Wasm.Parser: I64ExtendUI32 :: PlainInstr

+ Language.Wasm.Parser: I64Load :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Load16S :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Load16U :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Load32S :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Load32U :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Load8S :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Load8U :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Store :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Store16 :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Store32 :: MemArg -> PlainInstr

+ Language.Wasm.Parser: I64Store8 :: MemArg -> PlainInstr

+ Language.Wasm.Parser: IBinOp :: BitSize -> IBinOp -> PlainInstr

+ Language.Wasm.Parser: IReinterpretF :: BitSize -> PlainInstr

+ Language.Wasm.Parser: IRelOp :: BitSize -> IRelOp -> PlainInstr

+ Language.Wasm.Parser: ITruncFS :: BitSize -> BitSize -> PlainInstr

+ Language.Wasm.Parser: ITruncFU :: BitSize -> BitSize -> PlainInstr

+ Language.Wasm.Parser: ITruncSatFS :: BitSize -> BitSize -> PlainInstr

+ Language.Wasm.Parser: ITruncSatFU :: BitSize -> BitSize -> PlainInstr

+ Language.Wasm.Parser: IUnOp :: BitSize -> IUnOp -> PlainInstr

+ Language.Wasm.Parser: Ident :: Text -> Ident

+ Language.Wasm.Parser: IfInstr :: Maybe Ident -> TypeUse -> [Instruction] -> [Instruction] -> Instruction

+ Language.Wasm.Parser: Import :: [Text] -> Text -> Text -> ImportDesc -> Import

+ Language.Wasm.Parser: ImportFunc :: Maybe Ident -> TypeUse -> ImportDesc

+ Language.Wasm.Parser: ImportGlobal :: Maybe Ident -> GlobalType -> ImportDesc

+ Language.Wasm.Parser: ImportMemory :: Maybe Ident -> Limit -> ImportDesc

+ Language.Wasm.Parser: ImportTable :: Maybe Ident -> TableType -> ImportDesc

+ Language.Wasm.Parser: Index :: Natural -> Index

+ Language.Wasm.Parser: IndexedTypeUse :: TypeIndex -> Maybe FuncType -> TypeUse

+ Language.Wasm.Parser: Input :: Maybe Ident -> Text -> Meta

+ Language.Wasm.Parser: Invoke :: Maybe Ident -> Text -> [Expression] -> Action

+ Language.Wasm.Parser: LocalType :: Maybe Ident -> ValueType -> LocalType

+ Language.Wasm.Parser: LoopInstr :: Maybe Ident -> TypeUse -> [Instruction] -> Instruction

+ Language.Wasm.Parser: MFData :: DataSegment -> ModuleField

+ Language.Wasm.Parser: MFElem :: ElemSegment -> ModuleField

+ Language.Wasm.Parser: MFExport :: Export -> ModuleField

+ Language.Wasm.Parser: MFFunc :: Function -> ModuleField

+ Language.Wasm.Parser: MFGlobal :: Global -> ModuleField

+ Language.Wasm.Parser: MFImport :: Import -> ModuleField

+ Language.Wasm.Parser: MFMem :: Memory -> ModuleField

+ Language.Wasm.Parser: MFStart :: StartFunction -> ModuleField

+ Language.Wasm.Parser: MFTable :: Table -> ModuleField

+ Language.Wasm.Parser: MFType :: TypeDef -> ModuleField

+ Language.Wasm.Parser: Memory :: [Text] -> Maybe Ident -> Limit -> Memory

+ Language.Wasm.Parser: Meta :: Meta -> Command

+ Language.Wasm.Parser: ModuleDef :: ModuleDef -> Command

+ Language.Wasm.Parser: Named :: Ident -> Index

+ Language.Wasm.Parser: Nop :: PlainInstr

+ Language.Wasm.Parser: Output :: Maybe Ident -> Text -> Meta

+ Language.Wasm.Parser: ParamType :: Maybe Ident -> ValueType -> ParamType

+ Language.Wasm.Parser: PlainInstr :: PlainInstr -> Instruction

+ Language.Wasm.Parser: RawModDef :: Maybe Ident -> Module -> ModuleDef

+ Language.Wasm.Parser: Register :: Text -> Maybe Ident -> Command

+ Language.Wasm.Parser: Return :: PlainInstr

+ Language.Wasm.Parser: Script :: Maybe Ident -> Script -> Meta

+ Language.Wasm.Parser: Select :: PlainInstr

+ Language.Wasm.Parser: SetGlobal :: GlobalIndex -> PlainInstr

+ Language.Wasm.Parser: SetLocal :: LocalIndex -> PlainInstr

+ Language.Wasm.Parser: StartFunction :: FuncIndex -> StartFunction

+ Language.Wasm.Parser: Table :: [Text] -> Maybe Ident -> TableType -> Table

+ Language.Wasm.Parser: TeeLocal :: LocalIndex -> PlainInstr

+ Language.Wasm.Parser: TextModDef :: Maybe Ident -> Text -> ModuleDef

+ Language.Wasm.Parser: TypeDef :: Maybe Ident -> FuncType -> TypeDef

+ Language.Wasm.Parser: Unreachable :: PlainInstr

+ Language.Wasm.Parser: [$sel:blockType:PlainInstr] :: Instruction -> TypeUse

+ Language.Wasm.Parser: [$sel:body:Function] :: Function -> [Instruction]

+ Language.Wasm.Parser: [$sel:body:PlainInstr] :: Instruction -> [Instruction]

+ Language.Wasm.Parser: [$sel:datastring:DataSegment] :: DataSegment -> ByteString

+ Language.Wasm.Parser: [$sel:desc:Export] :: Export -> ExportDesc

+ Language.Wasm.Parser: [$sel:desc:Import] :: Import -> ImportDesc

+ Language.Wasm.Parser: [$sel:exportFuncAs:Function] :: Function -> [Text]

+ Language.Wasm.Parser: [$sel:exportGlobalAs:Global] :: Global -> [Text]

+ Language.Wasm.Parser: [$sel:falseBranch:PlainInstr] :: Instruction -> [Instruction]

+ Language.Wasm.Parser: [$sel:funcIndexes:ElemSegment] :: ElemSegment -> [FuncIndex]

+ Language.Wasm.Parser: [$sel:funcType:Function] :: Function -> TypeUse

+ Language.Wasm.Parser: [$sel:globalType:Global] :: Global -> GlobalType

+ Language.Wasm.Parser: [$sel:ident:Function] :: Function -> Maybe Ident

+ Language.Wasm.Parser: [$sel:ident:Global] :: Global -> Maybe Ident

+ Language.Wasm.Parser: [$sel:ident:LocalType] :: LocalType -> Maybe Ident

+ Language.Wasm.Parser: [$sel:ident:ParamType] :: ParamType -> Maybe Ident

+ Language.Wasm.Parser: [$sel:initializer:Global] :: Global -> [Instruction]

+ Language.Wasm.Parser: [$sel:label:PlainInstr] :: Instruction -> Maybe Ident

+ Language.Wasm.Parser: [$sel:localType:LocalType] :: LocalType -> ValueType

+ Language.Wasm.Parser: [$sel:locals:Function] :: Function -> [LocalType]

+ Language.Wasm.Parser: [$sel:memIndex:DataSegment] :: DataSegment -> MemoryIndex

+ Language.Wasm.Parser: [$sel:name:Export] :: Export -> Text

+ Language.Wasm.Parser: [$sel:name:Import] :: Import -> Text

+ Language.Wasm.Parser: [$sel:offset:DataSegment] :: DataSegment -> [Instruction]

+ Language.Wasm.Parser: [$sel:offset:ElemSegment] :: ElemSegment -> [Instruction]

+ Language.Wasm.Parser: [$sel:paramType:ParamType] :: ParamType -> ValueType

+ Language.Wasm.Parser: [$sel:params:FuncType] :: FuncType -> [ParamType]

+ Language.Wasm.Parser: [$sel:reExportAs:Import] :: Import -> [Text]

+ Language.Wasm.Parser: [$sel:results:FuncType] :: FuncType -> [ValueType]

+ Language.Wasm.Parser: [$sel:sourceModule:Import] :: Import -> Text

+ Language.Wasm.Parser: [$sel:tableIndex:ElemSegment] :: ElemSegment -> TableIndex

+ Language.Wasm.Parser: [$sel:trueBranch:PlainInstr] :: Instruction -> [Instruction]

+ Language.Wasm.Parser: data Action

+ Language.Wasm.Parser: data Assertion

+ Language.Wasm.Parser: data Command

+ Language.Wasm.Parser: data DataSegment

+ Language.Wasm.Parser: data ElemSegment

+ Language.Wasm.Parser: data Export

+ Language.Wasm.Parser: data ExportDesc

+ Language.Wasm.Parser: data FuncType

+ Language.Wasm.Parser: data Function

+ Language.Wasm.Parser: data Global

+ Language.Wasm.Parser: data Import

+ Language.Wasm.Parser: data ImportDesc

+ Language.Wasm.Parser: data Index

+ Language.Wasm.Parser: data Instruction

+ Language.Wasm.Parser: data LocalType

+ Language.Wasm.Parser: data Memory

+ Language.Wasm.Parser: data Meta

+ Language.Wasm.Parser: data ModuleDef

+ Language.Wasm.Parser: data ModuleField

+ Language.Wasm.Parser: data ParamType

+ Language.Wasm.Parser: data PlainInstr

+ Language.Wasm.Parser: data StartFunction

+ Language.Wasm.Parser: data Table

+ Language.Wasm.Parser: data TypeDef

+ Language.Wasm.Parser: data TypeUse

+ Language.Wasm.Parser: desugarize :: [ModuleField] -> Either String Module

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.DataSegment

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.ElemSegment

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Export

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.ExportDesc

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.FuncType

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Function

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Global

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Ident

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Import

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.ImportDesc

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Index

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Instruction

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.LocalType

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Memory

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.ModuleField

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.ParamType

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.PlainInstr

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.StartFunction

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.Table

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.TypeDef

+ Language.Wasm.Parser: instance Control.DeepSeq.NFData Language.Wasm.Parser.TypeUse

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Action

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Assertion

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Command

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.DataSegment

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.ElemSegment

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Export

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.ExportDesc

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.FunCtx

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.FuncType

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Function

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Global

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Ident

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Import

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.ImportDesc

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Index

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Instruction

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.LocalType

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Memory

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Meta

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Module

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.ModuleDef

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.ModuleField

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.ParamType

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.PlainInstr

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.StartFunction

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.Table

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.TypeDef

+ Language.Wasm.Parser: instance GHC.Classes.Eq Language.Wasm.Parser.TypeUse

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.DataSegment

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.ElemSegment

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Export

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.ExportDesc

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.FuncType

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Function

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Global

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Ident

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Import

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.ImportDesc

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Index

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Instruction

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.LocalType

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Memory

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.ModuleField

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.ParamType

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.PlainInstr

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.StartFunction

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.Table

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.TypeDef

+ Language.Wasm.Parser: instance GHC.Generics.Generic Language.Wasm.Parser.TypeUse

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Action

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Assertion

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Command

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.DataSegment

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.ElemSegment

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Export

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.ExportDesc

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.FunCtx

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.FuncType

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Function

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Global

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Ident

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Import

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.ImportDesc

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Index

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Instruction

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.LocalType

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Memory

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Meta

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Module

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.ModuleDef

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.ModuleField

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.ParamType

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.PlainInstr

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.StartFunction

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.Table

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.TypeDef

+ Language.Wasm.Parser: instance GHC.Show.Show Language.Wasm.Parser.TypeUse

+ Language.Wasm.Parser: newtype Ident

+ Language.Wasm.Parser: parseModule :: [Lexeme] -> Either String Module

+ Language.Wasm.Parser: parseModuleFields :: [Lexeme] -> Either String [ModuleField]

+ Language.Wasm.Parser: parseScript :: [Lexeme] -> Either String Script

+ Language.Wasm.Parser: type Script = [Command]

+ Language.Wasm.Validate: ($sel:getModule:ValidModule) :: ValidModule -> Module

+ Language.Wasm.Validate: AlignmentOverflow :: ValidationError

+ Language.Wasm.Validate: DuplicatedExportNames :: [String] -> ValidationError

+ Language.Wasm.Validate: FunctionIndexOutOfRange :: ValidationError

+ Language.Wasm.Validate: GlobalIndexOutOfRange :: Natural -> ValidationError

+ Language.Wasm.Validate: GlobalIsImmutable :: ValidationError

+ Language.Wasm.Validate: InvalidConstantExpr :: ValidationError

+ Language.Wasm.Validate: InvalidResultArity :: ValidationError

+ Language.Wasm.Validate: InvalidStartFunctionType :: ValidationError

+ Language.Wasm.Validate: InvalidTableType :: ValidationError

+ Language.Wasm.Validate: LabelIndexOutOfRange :: ValidationError

+ Language.Wasm.Validate: LocalIndexOutOfRange :: Natural -> ValidationError

+ Language.Wasm.Validate: MemoryIndexOutOfRange :: Natural -> ValidationError

+ Language.Wasm.Validate: MemoryLimitExceeded :: ValidationError

+ Language.Wasm.Validate: MinMoreThanMaxInMemoryLimit :: ValidationError

+ Language.Wasm.Validate: MoreThanOneMemory :: ValidationError

+ Language.Wasm.Validate: MoreThanOneTable :: ValidationError

+ Language.Wasm.Validate: ResultTypeDoesntMatch :: ValidationError

+ Language.Wasm.Validate: TableIndexOutOfRange :: Natural -> ValidationError

+ Language.Wasm.Validate: TypeIndexOutOfRange :: ValidationError

+ Language.Wasm.Validate: TypeMismatch :: Arrow -> Arrow -> ValidationError

+ Language.Wasm.Validate: [$sel:actual:DuplicatedExportNames] :: ValidationError -> Arrow

+ Language.Wasm.Validate: [$sel:expected:DuplicatedExportNames] :: ValidationError -> Arrow

+ Language.Wasm.Validate: data ValidModule

+ Language.Wasm.Validate: data ValidationError

+ Language.Wasm.Validate: instance GHC.Base.Monoid Language.Wasm.Validate.ValidationResult

+ Language.Wasm.Validate: instance GHC.Classes.Eq Language.Wasm.Validate.Arrow

+ Language.Wasm.Validate: instance GHC.Classes.Eq Language.Wasm.Validate.Ctx

+ Language.Wasm.Validate: instance GHC.Classes.Eq Language.Wasm.Validate.VType

+ Language.Wasm.Validate: instance GHC.Classes.Eq Language.Wasm.Validate.ValidModule

+ Language.Wasm.Validate: instance GHC.Classes.Eq Language.Wasm.Validate.ValidationError

+ Language.Wasm.Validate: instance GHC.Show.Show Language.Wasm.Validate.Arrow

+ Language.Wasm.Validate: instance GHC.Show.Show Language.Wasm.Validate.Ctx

+ Language.Wasm.Validate: instance GHC.Show.Show Language.Wasm.Validate.VType

+ Language.Wasm.Validate: instance GHC.Show.Show Language.Wasm.Validate.ValidModule

+ Language.Wasm.Validate: instance GHC.Show.Show Language.Wasm.Validate.ValidationError

+ Language.Wasm.Validate: instance Language.Wasm.Validate.ToEnd Language.Wasm.Structure.ValueType

+ Language.Wasm.Validate: instance Language.Wasm.Validate.ToEnd Language.Wasm.Validate.VType

+ Language.Wasm.Validate: instance Language.Wasm.Validate.ToEnd [Language.Wasm.Structure.ValueType]

+ Language.Wasm.Validate: instance Language.Wasm.Validate.ToEnd [Language.Wasm.Validate.VType]

+ Language.Wasm.Validate: isValid :: ValidationResult -> Bool

+ Language.Wasm.Validate: type ValidationResult = Either ValidationError ()

+ Language.Wasm.Validate: validate :: Module -> Either ValidationError ValidModule

Files

wasm.cabal +6/−6

wasm.cabal view

@@ -1,6 +1,6 @@ cabal-version:  2.2 name:           wasm-version:        1.1.0+version:        1.1.1 synopsis:       WebAssembly Language Toolkit and Interpreter description:   Library for parsing and interpreting WebAssembly, including:@@ -33,14 +33,14 @@       Language.Wasm.Script       Language.Wasm.Lexer       Language.Wasm.Structure-      Language.Wasm-  other-modules:-      Language.Wasm.Binary-      Language.Wasm.Builder-      Language.Wasm.FloatUtils       Language.Wasm.Interpreter       Language.Wasm.Parser       Language.Wasm.Validate+      Language.Wasm.Binary+      Language.Wasm.Builder+      Language.Wasm+  other-modules:+      Language.Wasm.FloatUtils       Paths_wasm   autogen-modules:       Paths_wasm