Milky2018/wasm_component/model

README
U
Alias
U
AliasTarget
U
BinaryKind
U
Canon
U
CanonOpt
U
CanonicalAbiPlan
U
Component
U
ComponentBinary
U
ComponentDecl
U
ComponentParseError
U
CoreInlineExport
U
CoreInstanceDecl
U
CoreInstanceExpr
U
CoreInstantiateArg
U
Export
U
ExportName
U
ExternDesc
U
FuncType
U
Import
U
ImportName
U
InlineExport
U
Instance
U
InstanceDecl
U
InstanceExpr
U
InstantiateArg
U
NameAttribute
U
Param
U
PrimValType
U
RecordField
U
ResourceKind
U
Section
U
Sort
U
SortIdx
U
Start
U
StringEncoding
U
TypeBound
U
TypeDef
U
ValType
U
ValueBound
U
VariantCase
V
canonical_abi_plan
V
canonical_discriminant_layout
V
canonical_flat_types
V
canonical_lift_core_func_type
V
canonical_lower_core_func_type
V
canonical_memory_layout
V
canonical_value_contains_memory
V
parse_alias_section
V
parse_canon_section
V
parse_component
V
parse_component_binary
V
parse_core_instance_section
V
parse_export_section
V
parse_import_section
V
parse_instance_section
V
parse_start_section
V
parse_type_section
V
sniff_binary_kind

Milky2018/wasm_component/model does not have a README file

ComponentParseError

pub suberror ComponentParseError {
  InvalidMagic
  UnexpectedEndOfInput
  Leb128TooLarge
  NotAComponent
  UnsupportedComponentPreamble(Int, Int)
  InvalidTypeSection
  InvalidInstanceSection
  InvalidAliasSection
  InvalidCanonSection
  InvalidStartSection
  UnsupportedCanonOpcode(Int)
  InvalidUtf8
  UnsupportedTypeOpcode(Int)
}

impl Show for ComponentParseError

ComponentParseError::output

source

fn ComponentParseError::output(self : ComponentParseError, logger : &Logger) -> Unit

ComponentParseError::to_string

source

fn ComponentParseError::to_string(self : ComponentParseError) -> String

Alias

source

pub(all) struct Alias {
  sort : Sort
  target : AliasTarget
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for Alias

Alias::equal

source

fn Alias::equal(Alias, Alias) -> Bool

Alias::not_equal

source

fn Alias::not_equal(x : Alias, y : Alias) -> Bool

Alias::output

source

fn Alias::output(self : Alias, logger : &Logger) -> Unit

Alias::to_repr

source

fn Alias::to_repr(Alias) -> @moonbitlang/core/debug.Repr
Repr

Alias::to_string

source

fn Alias::to_string(self : Alias) -> String

AliasTarget

source

pub(all) enum AliasTarget {
  Export(Int, String)
  CoreExport(Int, String)
  Outer(Int, Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

AliasTarget::equal

source

fn AliasTarget::equal(AliasTarget, AliasTarget) -> Bool

AliasTarget::not_equal

source

fn AliasTarget::not_equal(x : AliasTarget, y : AliasTarget) -> Bool

AliasTarget::to_repr

source

fn AliasTarget::to_repr(AliasTarget) -> @moonbitlang/core/debug.Repr
Repr

BinaryKind

source

pub(all) enum BinaryKind {
  CoreModule
  Component
  UnknownPreamble(Int, Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for BinaryKind

BinaryKind::equal

source

fn BinaryKind::equal(BinaryKind, BinaryKind) -> Bool

BinaryKind::not_equal

source

fn BinaryKind::not_equal(x : BinaryKind, y : BinaryKind) -> Bool

BinaryKind::output

source

fn BinaryKind::output(self : BinaryKind, logger : &Logger) -> Unit

BinaryKind::to_repr

source

fn BinaryKind::to_repr(BinaryKind) -> @moonbitlang/core/debug.Repr
Repr

BinaryKind::to_string

source

fn BinaryKind::to_string(self : BinaryKind) -> String

Canon

source

pub(all) enum Canon {
  Lift(Int, Array[CanonOpt], Int)
  Lower(Int, Array[CanonOpt])
  BackpressureInc
  BackpressureDec
  ContextGet(@Milky2018/wasm_core/types.ValueType
ValueType, Int)
  ContextSet(@Milky2018/wasm_core/types.ValueType
ValueType, Int)
  TaskReturn(ValType?, Array[CanonOpt])
  TaskCancel
  ThreadIndex
  ThreadYield(Bool)
  ThreadSuspendThenResume(Bool)
  ThreadYieldThenResume(Bool)
  ThreadSuspendThenPromote(Bool)
  ThreadYieldThenPromote(Bool)
  ThreadResumeLater
  ThreadSuspend(Bool)
  ThreadNewIndirect(Int, Int)
  WaitableSetNew
  WaitableSetWait(Bool, Int)
  WaitableSetPoll(Bool, Int)
  WaitableSetDrop
  WaitableJoin
  SubtaskCancel(Bool)
  SubtaskDrop
  StreamNew(Int)
  StreamRead(Int, Array[CanonOpt])
  StreamWrite(Int, Array[CanonOpt])
  StreamCancelRead(Int, Bool)
  StreamCancelWrite(Int, Bool)
  StreamDropReadable(Int)
  StreamDropWritable(Int)
  FutureNew(Int)
  FutureRead(Int, Array[CanonOpt])
  FutureWrite(Int, Array[CanonOpt])
  FutureCancelRead(Int, Bool)
  FutureCancelWrite(Int, Bool)
  FutureDropReadable(Int)
  FutureDropWritable(Int)
  ErrorContextNew(Array[CanonOpt])
  ErrorContextDebugMessage(Array[CanonOpt])
  ErrorContextDrop
  ResourceNew(Int)
  ResourceDrop(Int)
  ResourceRep(Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for Canon

Canon::equal

source

fn Canon::equal(Canon, Canon) -> Bool

Canon::not_equal

source

fn Canon::not_equal(x : Canon, y : Canon) -> Bool

Canon::output

source

fn Canon::output(self : Canon, logger : &Logger) -> Unit

Canon::to_repr

source

fn Canon::to_repr(Canon) -> @moonbitlang/core/debug.Repr
Repr

Canon::to_string

source

fn Canon::to_string(self : Canon) -> String

CanonOpt

source

pub(all) enum CanonOpt {
  StringEncoding(StringEncoding)
  Memory(Int)
  Realloc(Int)
  PostReturn(Int)
  CoreType(Int)
  Gc
  Async
  Callback(Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

CanonOpt::equal

source

fn CanonOpt::equal(CanonOpt, CanonOpt) -> Bool

CanonOpt::not_equal

source

fn CanonOpt::not_equal(x : CanonOpt, y : CanonOpt) -> Bool

CanonOpt::to_repr

source

fn CanonOpt::to_repr(CanonOpt) -> @moonbitlang/core/debug.Repr
Repr

Component

source

pub(all) struct Component {
  binary : ComponentBinary
  core_modules : Array[Bytes]
  core_instances : Array[Bytes]
  core_types : Array[Bytes]
  types : Array[TypeDef]
  imports : Array[Import]
  exports : Array[Export]
  instances : Array[Instance]
  aliases : Array[Alias]
  canons : Array[Canon]
  start : Start?
  components : Array[Component]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for Component

Component::equal

source

fn Component::equal(Component, Component) -> Bool

Component::isolated_copy

source

fn Component::isolated_copy(self : Component) -> Component raise ComponentParseError

Rebuild a component that shares no mutable state with self.

Component::not_equal

source

fn Component::not_equal(x : Component, y : Component) -> Bool

Component::output

source

fn Component::output(self : Component, logger : &Logger) -> Unit

Component::snapshot_bytes

source

fn Component::snapshot_bytes(self : Component) -> Bytes

Encode the component's immutable binary snapshot.

Bytes is immutable, so validation evidence can retain and expose this value without granting mutation access to the parsed component graph.

Component::to_repr

source

fn Component::to_repr(Component) -> @moonbitlang/core/debug.Repr
Repr

Component::to_string

source

fn Component::to_string(self : Component) -> String

ComponentBinary

source

pub struct ComponentBinary {
  version : Int
  layer : Int
  sections : Array[Section]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ComponentBinary::equal

source

fn ComponentBinary::equal(ComponentBinary, ComponentBinary) -> Bool

ComponentBinary::not_equal

source

fn ComponentBinary::not_equal(x : ComponentBinary, y : ComponentBinary) -> Bool

ComponentBinary::to_repr

source

fn ComponentBinary::to_repr(ComponentBinary) -> @moonbitlang/core/debug.Repr
Repr

ComponentDecl

source

pub(all) enum ComponentDecl {
  CoreType(Bytes)
  Type(TypeDef)
  AliasOuter(Int, Int, Int)
  AliasInstanceExport(Int, Int, String)
  Import(String, Array[NameAttribute], ExternDesc)
  Export(String, Array[NameAttribute], ExternDesc)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A subset of component type declarations (enough for WIT-encoded components).

ComponentDecl::equal

source

fn ComponentDecl::equal(ComponentDecl, ComponentDecl) -> Bool

ComponentDecl::not_equal

source

fn ComponentDecl::not_equal(x : ComponentDecl, y : ComponentDecl) -> Bool

ComponentDecl::to_repr

source

fn ComponentDecl::to_repr(ComponentDecl) -> @moonbitlang/core/debug.Repr
Repr

CoreInlineExport

source

pub(all) struct CoreInlineExport {
  name : String
  sortidx : SortIdx
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

CoreInlineExport::equal

source

fn CoreInlineExport::equal(CoreInlineExport, CoreInlineExport) -> Bool

CoreInlineExport::not_equal

source

fn CoreInlineExport::not_equal(x : CoreInlineExport, y : CoreInlineExport) -> Bool

CoreInlineExport::to_repr

source

fn CoreInlineExport::to_repr(CoreInlineExport) -> @moonbitlang/core/debug.Repr
Repr

CoreInstanceDecl

source

pub(all) struct CoreInstanceDecl {
  expr : CoreInstanceExpr
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

CoreInstanceDecl::equal

source

fn CoreInstanceDecl::equal(CoreInstanceDecl, CoreInstanceDecl) -> Bool

CoreInstanceDecl::not_equal

source

fn CoreInstanceDecl::not_equal(x : CoreInstanceDecl, y : CoreInstanceDecl) -> Bool

CoreInstanceDecl::to_repr

source

fn CoreInstanceDecl::to_repr(CoreInstanceDecl) -> @moonbitlang/core/debug.Repr
Repr

CoreInstanceExpr

source

pub(all) enum CoreInstanceExpr {
  Instantiate(Int, Array[CoreInstantiateArg])
  InlineExports(Array[CoreInlineExport])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

CoreInstanceExpr::equal

source

fn CoreInstanceExpr::equal(CoreInstanceExpr, CoreInstanceExpr) -> Bool

CoreInstanceExpr::not_equal

source

fn CoreInstanceExpr::not_equal(x : CoreInstanceExpr, y : CoreInstanceExpr) -> Bool

CoreInstanceExpr::to_repr

source

fn CoreInstanceExpr::to_repr(CoreInstanceExpr) -> @moonbitlang/core/debug.Repr
Repr

CoreInstantiateArg

source

pub(all) struct CoreInstantiateArg {
  name : String
  sortidx : SortIdx
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

CoreInstantiateArg::equal

source

fn CoreInstantiateArg::equal(CoreInstantiateArg, CoreInstantiateArg) -> Bool

CoreInstantiateArg::not_equal

source

fn CoreInstantiateArg::not_equal(x : CoreInstantiateArg, y : CoreInstantiateArg) -> Bool

CoreInstantiateArg::to_repr

source

fn CoreInstantiateArg::to_repr(CoreInstantiateArg) -> @moonbitlang/core/debug.Repr
Repr

Export

source

pub(all) struct Export {
  name : ExportName
  attributes : Array[NameAttribute]
  sortidx : SortIdx
  desc : ExternDesc?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Export::equal

source

fn Export::equal(Export, Export) -> Bool

Export::not_equal

source

fn Export::not_equal(x : Export, y : Export) -> Bool

Export::to_repr

source

fn Export::to_repr(Export) -> @moonbitlang/core/debug.Repr
Repr

ExportName

source

pub(all) enum ExportName {
  Plain(Bytes)
  WithVersion(Bytes, Bytes)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ExportName::equal

source

fn ExportName::equal(ExportName, ExportName) -> Bool

ExportName::not_equal

source

fn ExportName::not_equal(x : ExportName, y : ExportName) -> Bool

ExportName::to_repr

source

fn ExportName::to_repr(ExportName) -> @moonbitlang/core/debug.Repr
Repr

ExternDesc

source

pub(all) enum ExternDesc {
  CoreModuleType(Int)
  FuncType(Int)
  Value(ValueBound)
  Type(TypeBound)
  ComponentType(Int)
  InstanceType(Int)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for ExternDesc

ExternDesc::equal

source

fn ExternDesc::equal(ExternDesc, ExternDesc) -> Bool

ExternDesc::not_equal

source

fn ExternDesc::not_equal(x : ExternDesc, y : ExternDesc) -> Bool

ExternDesc::output

source

fn ExternDesc::output(self : ExternDesc, logger : &Logger) -> Unit

ExternDesc::to_repr

source

fn ExternDesc::to_repr(ExternDesc) -> @moonbitlang/core/debug.Repr
Repr

ExternDesc::to_string

source

fn ExternDesc::to_string(self : ExternDesc) -> String

FuncType

source

pub(all) struct FuncType {
  is_async : Bool
  params : Array[Param]
  result : ValType?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

FuncType::equal

source

fn FuncType::equal(FuncType, FuncType) -> Bool

FuncType::not_equal

source

fn FuncType::not_equal(x : FuncType, y : FuncType) -> Bool

FuncType::to_repr

source

fn FuncType::to_repr(FuncType) -> @moonbitlang/core/debug.Repr
Repr

Import

source

pub(all) struct Import {
  name : ImportName
  attributes : Array[NameAttribute]
  desc : ExternDesc
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Import::equal

source

fn Import::equal(Import, Import) -> Bool

Import::not_equal

source

fn Import::not_equal(x : Import, y : Import) -> Bool

Import::to_repr

source

fn Import::to_repr(Import) -> @moonbitlang/core/debug.Repr
Repr

ImportName

source

pub(all) enum ImportName {
  Plain(Bytes)
  WithVersion(Bytes, Bytes)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ImportName::equal

source

fn ImportName::equal(ImportName, ImportName) -> Bool

ImportName::not_equal

source

fn ImportName::not_equal(x : ImportName, y : ImportName) -> Bool

ImportName::to_repr

source

fn ImportName::to_repr(ImportName) -> @moonbitlang/core/debug.Repr
Repr

InlineExport

source

pub(all) struct InlineExport {
  name : String
  attributes : Array[NameAttribute]
  sortidx : SortIdx
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

InlineExport::equal

source

fn InlineExport::equal(InlineExport, InlineExport) -> Bool

InlineExport::not_equal

source

fn InlineExport::not_equal(x : InlineExport, y : InlineExport) -> Bool

InlineExport::to_repr

source

fn InlineExport::to_repr(InlineExport) -> @moonbitlang/core/debug.Repr
Repr

Instance

source

pub(all) struct Instance {
  expr : InstanceExpr
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Instance::equal

source

fn Instance::equal(Instance, Instance) -> Bool

Instance::not_equal

source

fn Instance::not_equal(x : Instance, y : Instance) -> Bool

Instance::to_repr

source

fn Instance::to_repr(Instance) -> @moonbitlang/core/debug.Repr
Repr

InstanceDecl

source

pub(all) enum InstanceDecl {
  CoreType(Bytes)
  Type(TypeDef)
  AliasOuter(Int, Int, Int)
  AliasInstanceExport(Int, Int, String)
  Export(String, Array[NameAttribute], ExternDesc)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A subset of instance type declarations (enough for wasmtime/component-spec).

InstanceDecl::equal

source

fn InstanceDecl::equal(InstanceDecl, InstanceDecl) -> Bool

InstanceDecl::not_equal

source

fn InstanceDecl::not_equal(x : InstanceDecl, y : InstanceDecl) -> Bool

InstanceDecl::to_repr

source

fn InstanceDecl::to_repr(InstanceDecl) -> @moonbitlang/core/debug.Repr
Repr

InstanceExpr

source

pub(all) enum InstanceExpr {
  Instantiate(Int, Array[InstantiateArg])
  InlineExports(Array[InlineExport])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for InstanceExpr

InstanceExpr::equal

source

fn InstanceExpr::equal(InstanceExpr, InstanceExpr) -> Bool

InstanceExpr::not_equal

source

fn InstanceExpr::not_equal(x : InstanceExpr, y : InstanceExpr) -> Bool

InstanceExpr::output

source

fn InstanceExpr::output(self : InstanceExpr, logger : &Logger) -> Unit

InstanceExpr::to_repr

source

fn InstanceExpr::to_repr(InstanceExpr) -> @moonbitlang/core/debug.Repr
Repr

InstanceExpr::to_string

source

fn InstanceExpr::to_string(self : InstanceExpr) -> String

InstantiateArg

source

pub(all) struct InstantiateArg {
  name : String
  sortidx : SortIdx
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

InstantiateArg::equal

source

fn InstantiateArg::equal(InstantiateArg, InstantiateArg) -> Bool

InstantiateArg::not_equal

source

fn InstantiateArg::not_equal(x : InstantiateArg, y : InstantiateArg) -> Bool

InstantiateArg::to_repr

source

fn InstantiateArg::to_repr(InstantiateArg) -> @moonbitlang/core/debug.Repr
Repr

NameAttribute

source

pub(all) enum NameAttribute {
  Implements(Bytes)
  VersionSuffix(Bytes)
  ExternalId(Bytes)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

NameAttribute::equal

source

fn NameAttribute::equal(NameAttribute, NameAttribute) -> Bool

NameAttribute::not_equal

source

fn NameAttribute::not_equal(x : NameAttribute, y : NameAttribute) -> Bool

NameAttribute::to_repr

source

fn NameAttribute::to_repr(NameAttribute) -> @moonbitlang/core/debug.Repr
Repr

Param

source

pub(all) struct Param {
  label : String
  ty : ValType
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Param::equal

source

fn Param::equal(Param, Param) -> Bool

Param::not_equal

source

fn Param::not_equal(x : Param, y : Param) -> Bool

Param::to_repr

source

fn Param::to_repr(Param) -> @moonbitlang/core/debug.Repr
Repr

PrimValType

source

pub(all) enum PrimValType {
  Bool
  S8
  U8
  S16
  U16
  S32
  U32
  S64
  U64
  F32
  F64
  Char
  String
  ErrorContext
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

PrimValType::equal

source

fn PrimValType::equal(PrimValType, PrimValType) -> Bool

PrimValType::not_equal

source

fn PrimValType::not_equal(x : PrimValType, y : PrimValType) -> Bool

PrimValType::to_repr

source

fn PrimValType::to_repr(PrimValType) -> @moonbitlang/core/debug.Repr
Repr

RecordField

source

pub(all) struct RecordField {
  label : String
  ty : ValType
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

RecordField::equal

source

fn RecordField::equal(RecordField, RecordField) -> Bool

RecordField::not_equal

source

fn RecordField::not_equal(x : RecordField, y : RecordField) -> Bool

RecordField::to_repr

source

fn RecordField::to_repr(RecordField) -> @moonbitlang/core/debug.Repr
Repr

ResourceKind

source

pub(all) enum ResourceKind {
  GuestDefined
  HostDefined
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ResourceKind::equal

source

fn ResourceKind::equal(ResourceKind, ResourceKind) -> Bool

ResourceKind::not_equal

source

fn ResourceKind::not_equal(x : ResourceKind, y : ResourceKind) -> Bool

ResourceKind::to_repr

source

fn ResourceKind::to_repr(ResourceKind) -> @moonbitlang/core/debug.Repr
Repr

Section

source

pub struct Section {
  id : Int
  payload : Bytes
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Section::equal

source

fn Section::equal(Section, Section) -> Bool

Section::not_equal

source

fn Section::not_equal(x : Section, y : Section) -> Bool

Section::to_repr

source

fn Section::to_repr(Section) -> @moonbitlang/core/debug.Repr
Repr

Sort

source

pub(all) enum Sort {
  Core(Int)
  Func
  Value
  Type
  Component
  Instance
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Sort::equal

source

fn Sort::equal(Sort, Sort) -> Bool

Sort::not_equal

source

fn Sort::not_equal(x : Sort, y : Sort) -> Bool

Sort::to_repr

source

fn Sort::to_repr(Sort) -> @moonbitlang/core/debug.Repr
Repr

SortIdx

source

pub(all) struct SortIdx {
  sort : Sort
  idx : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for SortIdx

SortIdx::equal

source

fn SortIdx::equal(SortIdx, SortIdx) -> Bool

SortIdx::not_equal

source

fn SortIdx::not_equal(x : SortIdx, y : SortIdx) -> Bool

SortIdx::output

source

fn SortIdx::output(self : SortIdx, logger : &Logger) -> Unit

SortIdx::to_repr

source

fn SortIdx::to_repr(SortIdx) -> @moonbitlang/core/debug.Repr
Repr

SortIdx::to_string

source

fn SortIdx::to_string(self : SortIdx) -> String

Start

source

pub(all) struct Start {
  func_idx : Int
  args : Array[Int]
  results : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for Start

Start::equal

source

fn Start::equal(Start, Start) -> Bool

Start::not_equal

source

fn Start::not_equal(x : Start, y : Start) -> Bool

Start::output

source

fn Start::output(self : Start, logger : &Logger) -> Unit

Start::to_repr

source

fn Start::to_repr(Start) -> @moonbitlang/core/debug.Repr
Repr

Start::to_string

source

fn Start::to_string(self : Start) -> String

StringEncoding

source

pub(all) enum StringEncoding {
  Utf8
  Utf16
  Latin1Utf16
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

StringEncoding::equal

source

fn StringEncoding::equal(StringEncoding, StringEncoding) -> Bool

StringEncoding::not_equal

source

fn StringEncoding::not_equal(x : StringEncoding, y : StringEncoding) -> Bool

StringEncoding::to_repr

source

fn StringEncoding::to_repr(StringEncoding) -> @moonbitlang/core/debug.Repr
Repr

TypeBound

source

pub(all) enum TypeBound {
  Eq(Int)
  SubResource
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

TypeBound::equal

source

fn TypeBound::equal(TypeBound, TypeBound) -> Bool

TypeBound::not_equal

source

fn TypeBound::not_equal(x : TypeBound, y : TypeBound) -> Bool

TypeBound::to_repr

source

fn TypeBound::to_repr(TypeBound) -> @moonbitlang/core/debug.Repr
Repr

TypeDef

source

pub(all) enum TypeDef {
  DefValType(PrimValType)
  FuncType(FuncType)
  List(ValType)
  FixedList(ValType, Int)
  MapType(ValType, ValType)
  Record(Array[RecordField])
  Variant(Array[VariantCase])
  Tuple(Array[ValType])
  Flags(Array[String])
  Enum(Array[String])
  Option(ValType)
  Result(ValType?, ValType?)
  Own(Int)
  Borrow(Int)
  Stream(ValType?)
  Future(ValType?)
  ResourceType(Int, Int, Int?, ResourceKind)
  ComponentType(Array[ComponentDecl])
  InstanceTypeEmpty
  InstanceType(Array[InstanceDecl])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for TypeDef

TypeDef::equal

source

fn TypeDef::equal(TypeDef, TypeDef) -> Bool

TypeDef::not_equal

source

fn TypeDef::not_equal(x : TypeDef, y : TypeDef) -> Bool

TypeDef::output

source

fn TypeDef::output(self : TypeDef, logger : &Logger) -> Unit

TypeDef::to_repr

source

fn TypeDef::to_repr(TypeDef) -> @moonbitlang/core/debug.Repr
Repr

TypeDef::to_string

source

fn TypeDef::to_string(self : TypeDef) -> String

ValType

source

pub(all) enum ValType {
  TypeIdx(Int)
  Prim(PrimValType)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ValType::equal

source

fn ValType::equal(ValType, ValType) -> Bool

ValType::not_equal

source

fn ValType::not_equal(x : ValType, y : ValType) -> Bool

ValType::to_repr

source

fn ValType::to_repr(ValType) -> @moonbitlang/core/debug.Repr
Repr

ValueBound

source

pub(all) enum ValueBound {
  Eq(Int)
  Type(ValType)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ValueBound::equal

source

fn ValueBound::equal(ValueBound, ValueBound) -> Bool

ValueBound::not_equal

source

fn ValueBound::not_equal(x : ValueBound, y : ValueBound) -> Bool

ValueBound::to_repr

source

fn ValueBound::to_repr(ValueBound) -> @moonbitlang/core/debug.Repr
Repr

VariantCase

source

pub(all) struct VariantCase {
  label : String
  ty : ValType?
  refines : Int?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

VariantCase::equal

source

fn VariantCase::equal(VariantCase, VariantCase) -> Bool

VariantCase::not_equal

source

fn VariantCase::not_equal(x : VariantCase, y : VariantCase) -> Bool

VariantCase::to_repr

source

fn VariantCase::to_repr(VariantCase) -> @moonbitlang/core/debug.Repr
Repr

parse_alias_section

source

fn parse_alias_section(payload : Bytes) -> Array[Alias] raise ComponentParseError

parse_canon_section

source

fn parse_canon_section(payload : Bytes) -> Array[Canon] raise ComponentParseError

parse_component

source

fn parse_component(bytes : Bytes) -> Component raise ComponentParseError

parse_component_binary

source

fn parse_component_binary(bytes : Bytes) -> ComponentBinary raise ComponentParseError

parse_core_instance_section

source

fn parse_core_instance_section(payload : Bytes) -> Array[CoreInstanceDecl] raise ComponentParseError

parse_export_section

source

fn parse_export_section(payload : Bytes) -> Array[Export] raise ComponentParseError

parse_import_section

source

fn parse_import_section(payload : Bytes) -> Array[Import] raise ComponentParseError

parse_instance_section

source

fn parse_instance_section(payload : Bytes) -> Array[Instance] raise ComponentParseError

parse_start_section

source

fn parse_start_section(payload : Bytes) -> Start raise ComponentParseError

parse_type_section

source

fn parse_type_section(payload : Bytes) -> Array[TypeDef] raise ComponentParseError

sniff_binary_kind

source

fn sniff_binary_kind(bytes : Bytes) -> BinaryKind?

Source Files

Site source Report issue Packages Build queue Skills Statistics

#ComponentParseError

#ComponentParseError::output

#ComponentParseError::to_string

#Alias

#Alias::equal

#Alias::not_equal

#Alias::output

#Alias::to_repr

#Alias::to_string

#AliasTarget

#AliasTarget::equal

#AliasTarget::not_equal

#AliasTarget::to_repr

#BinaryKind

#BinaryKind::equal

#BinaryKind::not_equal

#BinaryKind::output

#BinaryKind::to_repr

#BinaryKind::to_string

#Canon

#Canon::equal

#Canon::not_equal

#Canon::output

#Canon::to_repr

#Canon::to_string

#CanonOpt

#CanonOpt::equal

#CanonOpt::not_equal

#CanonOpt::to_repr

#Component

#Component::equal

#Component::isolated_copy

#Component::not_equal

#Component::output

#Component::snapshot_bytes

#Component::to_repr

#Component::to_string

#ComponentBinary

#ComponentBinary::equal

#ComponentBinary::not_equal

#ComponentBinary::to_repr

#ComponentDecl

#ComponentDecl::equal

#ComponentDecl::not_equal

#ComponentDecl::to_repr

#CoreInlineExport

#CoreInlineExport::equal

#CoreInlineExport::not_equal

#CoreInlineExport::to_repr

#CoreInstanceDecl

#CoreInstanceDecl::equal

#CoreInstanceDecl::not_equal

#CoreInstanceDecl::to_repr

#CoreInstanceExpr

#CoreInstanceExpr::equal

#CoreInstanceExpr::not_equal

#CoreInstanceExpr::to_repr

#CoreInstantiateArg

#CoreInstantiateArg::equal

#CoreInstantiateArg::not_equal

#CoreInstantiateArg::to_repr

#Export

#Export::equal

#Export::not_equal

#Export::to_repr

#ExportName

#ExportName::equal

#ExportName::not_equal

#ExportName::to_repr

#ExternDesc

#ExternDesc::equal

#ExternDesc::not_equal

#ExternDesc::output

#ExternDesc::to_repr

#ExternDesc::to_string

#FuncType

#FuncType::equal

#FuncType::not_equal

#FuncType::to_repr

#Import

ComponentParseError

ComponentParseError::output

ComponentParseError::to_string

Alias

Alias::equal

Alias::not_equal

Alias::output

Alias::to_repr

Alias::to_string

AliasTarget

AliasTarget::equal

AliasTarget::not_equal

AliasTarget::to_repr

BinaryKind

BinaryKind::equal

BinaryKind::not_equal

BinaryKind::output

BinaryKind::to_repr

BinaryKind::to_string

Canon

Canon::equal

Canon::not_equal

Canon::output

Canon::to_repr

Canon::to_string

CanonOpt

CanonOpt::equal

CanonOpt::not_equal

CanonOpt::to_repr

Component

Component::equal

Component::isolated_copy

Component::not_equal

Component::output

Component::snapshot_bytes

Component::to_repr

Component::to_string

ComponentBinary

ComponentBinary::equal

ComponentBinary::not_equal

ComponentBinary::to_repr

ComponentDecl

ComponentDecl::equal

ComponentDecl::not_equal

ComponentDecl::to_repr

CoreInlineExport

CoreInlineExport::equal

CoreInlineExport::not_equal

CoreInlineExport::to_repr

CoreInstanceDecl

CoreInstanceDecl::equal

CoreInstanceDecl::not_equal

CoreInstanceDecl::to_repr

CoreInstanceExpr

CoreInstanceExpr::equal

CoreInstanceExpr::not_equal

CoreInstanceExpr::to_repr

CoreInstantiateArg

CoreInstantiateArg::equal

CoreInstantiateArg::not_equal

CoreInstantiateArg::to_repr

Export

Export::equal

Export::not_equal

Export::to_repr

ExportName

ExportName::equal

ExportName::not_equal

ExportName::to_repr

ExternDesc

ExternDesc::equal

ExternDesc::not_equal

ExternDesc::output

ExternDesc::to_repr

ExternDesc::to_string

FuncType

FuncType::equal

FuncType::not_equal

FuncType::to_repr

Import