🥮 mooncakes.io

    wit

    WIT parser and resolver in MoonBit

    wit
    wasm
    component
    Download zip
    Author
    Version
    0.4.0
    License
    Apache-2.0
    Repository
    Last updated
    6 hours ago
    Downloads
    65K

    #mizchi/wit

    WIT (WebAssembly Interface Types) parser and resolver written in MoonBit.

    #Features

    • Lexer & Parser – Tokenize and parse WIT source into a typed AST
    • Resolver – Resolve parsed WIT into a flat, index-based representation suitable for code generation
    • Path resolver – Load WIT files from deps/ directory layouts produced by wkg
    • Current WIT syntax – Async functions, optional future/stream payloads, error contexts, fixed-length lists, maps, file-local aliases, nested packages, external IDs, and property accessors

    See WIT support and validation limits and 0.4.0 API changes. Verified with MoonBit 0.1.20261104.

    #Install

    moon add mizchi/wit

    #Usage

    #Parse a WIT source string

    let source = "package local:hello;\n\ninterface greet {\n  greet: func(name: string) -> string;\n}\n\nworld hello {\n  export greet;\n}\n"
    inspect(parse(source))

    #Resolve to a flat model

    let source = "package local:hello;\n\ninterface greet {\n  greet: func(name: string) -> string;\n}\n\nworld hello {\n  export greet;\n}\n"
    inspect(resolve(source))

    #API

    FunctionDescription
    parse(String) -> Result[WitFile, ParseError]Parse a WIT source string into an AST
    parse_path(String) -> Result[WitFile, ParseError]Parse a WIT file from a file path
    resolve(String) -> Result[Resolve, ParseError]Parse and resolve a WIT source string
    resolve_path(String, world? : String) -> Result[ResolveInput, ParseError]Resolve WIT from a directory path with optional world selection
    tokenize(String) -> Result[Array[Token], ParseError]Tokenize a WIT source string

    #License

    Apache-2.0

    ParseError

    source
    pub suberror ParseError {
      Message(String, Int)
    } derive(Eq, 
    Debug    )

    impl Show for ParseError

    ParseError::equal

    source
    fn ParseError::equal(ParseError, ParseError) -> Bool

    ParseError::not_equal

    source
    fn ParseError::not_equal(x : ParseError, y : ParseError) -> Bool

    ParseError::output

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

    ParseError::to_repr

    source

    ParseError::to_string

    source
    fn ParseError::to_string(self : ParseError) -> String

    Field

    source
    pub struct Field {
      name : String
      ty : TypeExpr
    } derive(Eq, 
    Debug    )

    impl Show for Field

    Field::equal

    source
    fn Field::equal(Field, Field) -> Bool

    Field::not_equal

    source
    fn Field::not_equal(x : Field, y : Field) -> Bool

    Field::output

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

    Field::to_repr

    source

    Field::to_string

    source
    fn Field::to_string(self : Field) -> String

    Function

    source
    pub struct Function {
      name : String
      kind : FunctionKind
      params : Array[Param]
      result : TypeExpr?
      docs : String?
      external_id : String?
    } derive(Eq, 
    Debug    )

    impl Show for Function

    Function::equal

    source
    fn Function::equal(Function, Function) -> Bool

    Function::not_equal

    source
    fn Function::not_equal(x : Function, y : Function) -> Bool

    Function::output

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

    Function::to_repr

    source

    Function::to_string

    source
    fn Function::to_string(self : Function) -> String

    FunctionKind

    source
    pub enum FunctionKind {
      Freestanding
      AsyncFreestanding
      Getter
      Setter
      Constructor(String)
      Method(String)
      AsyncMethod(String)
      MethodGetter(String)
      MethodSetter(String)
      Static(String)
      AsyncStatic(String)
      StaticGetter(String)
      StaticSetter(String)
    } derive(Eq, 
    Debug    )

    FunctionKind::equal

    source

    FunctionKind::not_equal

    source
    fn FunctionKind::not_equal(x : FunctionKind, y : FunctionKind) -> Bool

    FunctionKind::output

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

    FunctionKind::to_repr

    source

    FunctionKind::to_string

    source
    fn FunctionKind::to_string(self : FunctionKind) -> String

    IncludeDecl

    source
    pub struct IncludeDecl {
      path : UsePath
      renames : Array[IncludeRename]
    } derive(Eq, 
    Debug    )

    impl Show for IncludeDecl

    IncludeDecl::equal

    source
    fn IncludeDecl::equal(IncludeDecl, IncludeDecl) -> Bool

    IncludeDecl::not_equal

    source
    fn IncludeDecl::not_equal(x : IncludeDecl, y : IncludeDecl) -> Bool

    IncludeDecl::output

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

    IncludeDecl::to_repr

    source

    IncludeDecl::to_string

    source
    fn IncludeDecl::to_string(self : IncludeDecl) -> String

    IncludeRename

    source
    pub struct IncludeRename {
      from : String
      to : String
    } derive(Eq, 
    Debug    )

    IncludeRename::equal

    source

    IncludeRename::not_equal

    source
    fn IncludeRename::not_equal(x : IncludeRename, y : IncludeRename) -> Bool

    IncludeRename::output

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

    IncludeRename::to_repr

    source

    IncludeRename::to_string

    source
    fn IncludeRename::to_string(self : IncludeRename) -> String

    InlineInterface

    source
    pub struct InlineInterface {
      name : String
      docs : String?
      items : Array[InterfaceItem]
    } derive(Eq, 
    Debug    )

    InlineInterface::equal

    source

    InlineInterface::not_equal

    source
    fn InlineInterface::not_equal(x : InlineInterface, y : InlineInterface) -> Bool

    InlineInterface::output

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

    InlineInterface::to_repr

    source

    InlineInterface::to_string

    source
    fn InlineInterface::to_string(self : InlineInterface) -> String

    Interface

    source
    pub struct Interface {
      name : String
      docs : String?
      items : Array[InterfaceItem]
    } derive(Eq, 
    Debug    )

    impl Show for Interface

    Interface::equal

    source
    fn Interface::equal(Interface, Interface) -> Bool

    Interface::not_equal

    source
    fn Interface::not_equal(x : Interface, y : Interface) -> Bool

    Interface::output

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

    Interface::to_repr

    source

    Interface::to_string

    source
    fn Interface::to_string(self : Interface) -> String

    InterfaceItem

    source
    pub enum InterfaceItem {
      Use(UseDecl)
      TypeDef(TypeDef)
      Function(Function)
    } derive(Eq, 
    Debug    )

    InterfaceItem::equal

    source

    InterfaceItem::not_equal

    source
    fn InterfaceItem::not_equal(x : InterfaceItem, y : InterfaceItem) -> Bool

    InterfaceItem::output

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

    InterfaceItem::to_repr

    source

    InterfaceItem::to_string

    source
    fn InterfaceItem::to_string(self : InterfaceItem) -> String

    PackageName

    source
    pub struct PackageName {
      ns : String
      name : String
      version : String?
    } derive(Eq, 
    Debug    )

    impl Show for PackageName

    PackageName::equal

    source
    fn PackageName::equal(PackageName, PackageName) -> Bool

    PackageName::not_equal

    source
    fn PackageName::not_equal(x : PackageName, y : PackageName) -> Bool

    PackageName::output

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

    PackageName::to_repr

    source

    PackageName::to_string

    source
    fn PackageName::to_string(self : PackageName) -> String

    Param

    source
    pub struct Param {
      name : String
      ty : TypeExpr
    } derive(Eq, 
    Debug    )

    impl Show for Param

    Param::equal

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

    Param::not_equal

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

    Param::output

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

    Param::to_repr

    source

    Param::to_string

    source
    fn Param::to_string(self : Param) -> String

    RFunction

    source
    pub struct RFunction {
      name : String
      kind : RFunctionKind
      params : Array[(String, RType)]
      result : RType?
      docs : String?
      external_id : String?
    } derive(Eq, 
    Debug    )

    Function definition
    impl Show for RFunction
    impl ToJson for RFunction

    RFunction::equal

    source
    fn RFunction::equal(RFunction, RFunction) -> Bool

    RFunction::not_equal

    source
    fn RFunction::not_equal(x : RFunction, y : RFunction) -> Bool

    RFunction::output

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

    RFunction::to_json

    source

    RFunction::to_repr

    source

    RFunction::to_string

    source
    fn RFunction::to_string(self : RFunction) -> String

    RFunctionKind

    source
    pub enum RFunctionKind {
      Freestanding
      AsyncFreestanding
      Getter
      Setter
      Constructor(Int)
      Method(Int)
      AsyncMethod(Int)
      MethodGetter(Int)
      MethodSetter(Int)
      Static(Int)
      AsyncStatic(Int)
      StaticGetter(Int)
      StaticSetter(Int)
    } derive(Eq, 
    Debug    )

    Function kind

    RFunctionKind::equal

    source

    RFunctionKind::not_equal

    source
    fn RFunctionKind::not_equal(x : RFunctionKind, y : RFunctionKind) -> Bool

    RFunctionKind::output

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

    RFunctionKind::to_json

    source

    RFunctionKind::to_repr

    source

    RFunctionKind::to_string

    source
    fn RFunctionKind::to_string(self : RFunctionKind) -> String

    RHandleKind

    source
    pub enum RHandleKind {
      Own(Int)
      Borrow(Int)
    } derive(Eq, 
    Debug    )

    impl Show for RHandleKind

    RHandleKind::equal

    source
    fn RHandleKind::equal(RHandleKind, RHandleKind) -> Bool

    RHandleKind::not_equal

    source
    fn RHandleKind::not_equal(x : RHandleKind, y : RHandleKind) -> Bool

    RHandleKind::output

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

    RHandleKind::to_json

    source

    RHandleKind::to_repr

    source

    RHandleKind::to_string

    source
    fn RHandleKind::to_string(self : RHandleKind) -> String

    RInterface

    source
    pub struct RInterface {
      name : String?
      docs : String?
      functions : Map[String, RFunction]
      types : Map[String, Int]
      pkg : Int?
    } derive(Eq, 
    Debug    )

    impl Show for RInterface

    RInterface::equal

    source
    fn RInterface::equal(RInterface, RInterface) -> Bool

    RInterface::not_equal

    source
    fn RInterface::not_equal(x : RInterface, y : RInterface) -> Bool

    RInterface::output

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

    RInterface::to_json

    source

    RInterface::to_repr

    source

    RInterface::to_string

    source
    fn RInterface::to_string(self : RInterface) -> String

    RInterfaceRef

    source
    pub struct RInterfaceRef {
      id : Int
      external_id : String?
    } derive(Eq, 
    Debug    )

    RInterfaceRef::equal

    source

    RInterfaceRef::not_equal

    source
    fn RInterfaceRef::not_equal(x : RInterfaceRef, y : RInterfaceRef) -> Bool

    RInterfaceRef::output

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

    RInterfaceRef::to_json

    source

    RInterfaceRef::to_repr

    source

    RInterfaceRef::to_string

    source
    fn RInterfaceRef::to_string(self : RInterfaceRef) -> String

    RPackage

    source
    pub struct RPackage {
      name : RPackageName
      interfaces : Map[String, Int]
      worlds : Map[String, Int]
    } derive(Eq, 
    Debug    )

    impl Show for RPackage
    impl ToJson for RPackage

    RPackage::equal

    source
    fn RPackage::equal(RPackage, RPackage) -> Bool

    RPackage::not_equal

    source
    fn RPackage::not_equal(x : RPackage, y : RPackage) -> Bool

    RPackage::output

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

    RPackage::to_json

    source

    RPackage::to_repr

    source

    RPackage::to_string

    source
    fn RPackage::to_string(self : RPackage) -> String

    RPackageName

    source
    pub struct RPackageName {
      ns : String
      name : String
      version : String?
    } derive(Eq, 
    Debug    )

    RPackageName::equal

    source

    RPackageName::not_equal

    source
    fn RPackageName::not_equal(x : RPackageName, y : RPackageName) -> Bool

    RPackageName::output

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

    RPackageName::to_json

    source

    RPackageName::to_repr

    source

    RPackageName::to_string

    source
    fn RPackageName::to_string(self : RPackageName) -> String

    RRecordField

    source
    pub struct RRecordField {
      name : String
      field_type : RType
    } derive(Eq, 
    Debug    )

    RRecordField::equal

    source

    RRecordField::not_equal

    source
    fn RRecordField::not_equal(x : RRecordField, y : RRecordField) -> Bool

    RRecordField::output

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

    RRecordField::to_json

    source

    RRecordField::to_repr

    source

    RRecordField::to_string

    source
    fn RRecordField::to_string(self : RRecordField) -> String

    RType

    source
    pub enum RType {
      Bool
      U8
      U16
      U32
      U64
      S8
      S16
      S32
      S64
      F32
      F64
      Char
      String_
      ErrorContext
      Id(Int)
    } derive(Eq, 
    Debug    )

    Resolve type reference
    impl Show for RType
    impl ToJson for RType

    RType::equal

    source
    fn RType::equal(RType, RType) -> Bool

    RType::not_equal

    source
    fn RType::not_equal(x : RType, y : RType) -> Bool

    RType::output

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

    RType::to_json

    source

    RType::to_repr

    source

    RType::to_string

    source
    fn RType::to_string(self : RType) -> String

    RTypeDef

    source
    pub struct RTypeDef {
      name : String?
      kind : RTypeKind
      owner : RTypeOwner
      docs : String?
      external_id : String?
    } derive(Eq, 
    Debug    )

    impl Show for RTypeDef
    impl ToJson for RTypeDef

    RTypeDef::equal

    source
    fn RTypeDef::equal(RTypeDef, RTypeDef) -> Bool

    RTypeDef::not_equal

    source
    fn RTypeDef::not_equal(x : RTypeDef, y : RTypeDef) -> Bool

    RTypeDef::output

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

    RTypeDef::to_json

    source

    RTypeDef::to_repr

    source

    RTypeDef::to_string

    source
    fn RTypeDef::to_string(self : RTypeDef) -> String

    RTypeKind

    source
    pub enum RTypeKind {
      Record(Array[RRecordField])
      Variant(Array[RVariantCase])
      List(RType)
      FixedLengthList(RType, UInt)
      Map(RType, RType)
      Option(RType)
      Future(RType?)
      Stream(RType?)
      Result(ok~ : RType?, err~ : RType?)
      Tuple(Array[RType])
      Flags(Array[String])
      Enum(Array[String])
      Alias(RType)
      Resource
      Handle(RHandleKind)
    } derive(Eq, 
    Debug    )

    impl Show for RTypeKind
    impl ToJson for RTypeKind

    RTypeKind::equal

    source
    fn RTypeKind::equal(RTypeKind, RTypeKind) -> Bool

    RTypeKind::not_equal

    source
    fn RTypeKind::not_equal(x : RTypeKind, y : RTypeKind) -> Bool

    RTypeKind::output

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

    RTypeKind::to_json

    source

    RTypeKind::to_repr

    source

    RTypeKind::to_string

    source
    fn RTypeKind::to_string(self : RTypeKind) -> String

    RTypeOwner

    source
    pub enum RTypeOwner {
      Interface(Int)
      World(Int)
      None
    } derive(Eq, 
    Debug    )

    impl Show for RTypeOwner

    RTypeOwner::equal

    source
    fn RTypeOwner::equal(RTypeOwner, RTypeOwner) -> Bool

    RTypeOwner::not_equal

    source
    fn RTypeOwner::not_equal(x : RTypeOwner, y : RTypeOwner) -> Bool

    RTypeOwner::output

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

    RTypeOwner::to_json

    source

    RTypeOwner::to_repr

    source

    RTypeOwner::to_string

    source
    fn RTypeOwner::to_string(self : RTypeOwner) -> String

    RVariantCase

    source
    pub struct RVariantCase {
      name : String
      case_type : RType?
    } derive(Eq, 
    Debug    )

    RVariantCase::equal

    source

    RVariantCase::not_equal

    source
    fn RVariantCase::not_equal(x : RVariantCase, y : RVariantCase) -> Bool

    RVariantCase::output

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

    RVariantCase::to_json

    source

    RVariantCase::to_repr

    source

    RVariantCase::to_string

    source
    fn RVariantCase::to_string(self : RVariantCase) -> String

    RWorld

    source
    pub struct RWorld {
      name : String
      docs : String?
      imports : Map[String, RWorldItem]
      exports : Map[String, RWorldItem]
      pkg : Int?
    } derive(Eq, 
    Debug    )

    impl Show for RWorld
    impl ToJson for RWorld

    RWorld::equal

    source
    fn RWorld::equal(RWorld, RWorld) -> Bool

    RWorld::not_equal

    source
    fn RWorld::not_equal(x : RWorld, y : RWorld) -> Bool

    RWorld::output

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

    RWorld::to_json

    source

    RWorld::to_repr

    source

    RWorld::to_string

    source
    fn RWorld::to_string(self : RWorld) -> String

    RWorldItem

    source
    pub enum RWorldItem {
      Interface(RInterfaceRef)
      Function(RFunction)
      Type(Int)
    } derive(Eq, 
    Debug    )

    World item
    impl Show for RWorldItem

    RWorldItem::equal

    source
    fn RWorldItem::equal(RWorldItem, RWorldItem) -> Bool

    RWorldItem::not_equal

    source
    fn RWorldItem::not_equal(x : RWorldItem, y : RWorldItem) -> Bool

    RWorldItem::output

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

    RWorldItem::to_json

    source

    RWorldItem::to_repr

    source

    RWorldItem::to_string

    source
    fn RWorldItem::to_string(self : RWorldItem) -> String

    Resolve

    source
    pub struct Resolve {
      worlds : Array[RWorld]
      interfaces : Array[RInterface]
      types : Array[RTypeDef]
      packages : Array[RPackage]
    } derive(Eq, 
    Debug    )

    impl Show for Resolve
    impl ToJson for Resolve

    Resolve::equal

    source
    fn Resolve::equal(Resolve, Resolve) -> Bool

    Resolve::not_equal

    source
    fn Resolve::not_equal(x : Resolve, y : Resolve) -> Bool

    Resolve::output

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

    Resolve::to_json

    source

    Resolve::to_repr

    source

    Resolve::to_string

    source
    fn Resolve::to_string(self : Resolve) -> String

    ResolveInput

    source
    pub struct ResolveInput {
      resolve : Resolve
      world_id : Int
    } derive(Eq, 
    Debug    )

    ResolveInput::equal

    source

    ResolveInput::not_equal

    source
    fn ResolveInput::not_equal(x : ResolveInput, y : ResolveInput) -> Bool

    ResolveInput::output

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

    ResolveInput::to_json

    source

    ResolveInput::to_repr

    source

    ResolveInput::to_string

    source
    fn ResolveInput::to_string(self : ResolveInput) -> String

    ResolvedInterfaceInfo

    source
    pub struct ResolvedInterfaceInfo {
      interface_id : Int
      name : String?
      docs : String?
      package_name : RPackageName?
      functions : Map[String, RFunction]
      types : Map[String, ResolvedTypeInfo]
    } derive(Eq, 
    Debug    )

    ResolvedInterfaceInfo::equal

    source

    ResolvedInterfaceInfo::not_equal

    source

    ResolvedInterfaceInfo::output

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

    ResolvedInterfaceInfo::to_repr

    source

    ResolvedInterfaceInfo::to_string

    source
    fn ResolvedInterfaceInfo::to_string(self : ResolvedInterfaceInfo) -> String

    ResolvedTypeInfo

    source
    pub struct ResolvedTypeInfo {
      local_name : String
      type_id : Int
      type_name : String?
      type_kind : RTypeKind
      owner : RTypeOwner
      owner_package : RPackageName?
      owner_interface : String?
      owner_world : String?
    } derive(Eq, 
    Debug    )

    ResolvedTypeInfo::equal

    source

    ResolvedTypeInfo::not_equal

    source
    fn ResolvedTypeInfo::not_equal(x : ResolvedTypeInfo, y : ResolvedTypeInfo) -> Bool

    ResolvedTypeInfo::output

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

    ResolvedTypeInfo::to_repr

    source

    ResolvedTypeInfo::to_string

    source
    fn ResolvedTypeInfo::to_string(self : ResolvedTypeInfo) -> String

    Resource

    source
    pub struct Resource {
      funcs : Array[Function]
    } derive(Eq, 
    Debug    )

    impl Show for Resource

    Resource::equal

    source
    fn Resource::equal(Resource, Resource) -> Bool

    Resource::not_equal

    source
    fn Resource::not_equal(x : Resource, y : Resource) -> Bool

    Resource::output

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

    Resource::to_repr

    source

    Resource::to_string

    source
    fn Resource::to_string(self : Resource) -> String

    Token

    source
    pub struct Token {
      token_type : TokenType
      offset : Int
    } derive(Eq, 
    Debug    )

    impl Show for Token

    Token::equal

    source
    fn Token::equal(Token, Token) -> Bool

    Token::not_equal

    source
    fn Token::not_equal(x : Token, y : Token) -> Bool

    Token::output

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

    Token::to_repr

    source

    Token::to_string

    source
    fn Token::to_string(self : Token) -> String

    TokenType

    source
    pub enum TokenType {
      Ident(String)
      Keyword(String)
      Symbol(String)
      StringLit(String)
      Number(String)
      Doc(String)
      Eof
    } derive(Eq, 
    Debug    )

    impl Show for TokenType

    TokenType::equal

    source
    fn TokenType::equal(TokenType, TokenType) -> Bool

    TokenType::not_equal

    source
    fn TokenType::not_equal(x : TokenType, y : TokenType) -> Bool

    TokenType::output

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

    TokenType::to_repr

    source

    TokenType::to_string

    source
    fn TokenType::to_string(self : TokenType) -> String

    TypeDef

    source
    pub struct TypeDef {
      name : String
      kind : TypeDefKind
      docs : String?
      external_id : String?
    } derive(Eq, 
    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

    TypeDef::to_string

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

    TypeDefKind

    source
    pub enum TypeDefKind {
      Record(Array[Field])
      Enum(Array[String])
      Flags(Array[String])
      Variant(Array[VariantCase])
      Alias(TypeExpr)
      Resource(Resource)
    } derive(Eq, 
    Debug    )

    impl Show for TypeDefKind

    TypeDefKind::equal

    source
    fn TypeDefKind::equal(TypeDefKind, TypeDefKind) -> Bool

    TypeDefKind::not_equal

    source
    fn TypeDefKind::not_equal(x : TypeDefKind, y : TypeDefKind) -> Bool

    TypeDefKind::output

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

    TypeDefKind::to_repr

    source

    TypeDefKind::to_string

    source
    fn TypeDefKind::to_string(self : TypeDefKind) -> String

    TypeExpr

    source
    pub enum TypeExpr {
      Bool
      U8
      U16
      U32
      U64
      S8
      S16
      S32
      S64
      F32
      F64
      Char
      String_
      ErrorContext
      Id(String)
      List(TypeExpr)
      FixedLengthList(TypeExpr, UInt)
      Map(TypeExpr, TypeExpr)
      Option(TypeExpr)
      Future(TypeExpr?)
      Stream(TypeExpr?)
      Result(TypeExpr?, TypeExpr?)
      Tuple(Array[TypeExpr])
      Own(String)
      Borrow(String)
    } derive(Eq, 
    Debug    )

    impl Show for TypeExpr

    TypeExpr::equal

    source
    fn TypeExpr::equal(TypeExpr, TypeExpr) -> Bool

    TypeExpr::not_equal

    source
    fn TypeExpr::not_equal(x : TypeExpr, y : TypeExpr) -> Bool

    TypeExpr::output

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

    TypeExpr::to_repr

    source

    TypeExpr::to_string

    source
    fn TypeExpr::to_string(self : TypeExpr) -> String

    UseDecl

    source
    pub struct UseDecl {
      from : UsePath
      names : Array[String]
      renames : Array[IncludeRename]
    } derive(Eq, 
    Debug    )

    impl Show for UseDecl

    UseDecl::equal

    source
    fn UseDecl::equal(UseDecl, UseDecl) -> Bool

    UseDecl::not_equal

    source
    fn UseDecl::not_equal(x : UseDecl, y : UseDecl) -> Bool

    UseDecl::output

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

    UseDecl::to_repr

    source

    UseDecl::to_string

    source
    fn UseDecl::to_string(self : UseDecl) -> String

    UsePath

    source
    pub struct UsePath {
      pkg : PackageName?
      interface : String
    } derive(Eq, 
    Debug    )

    impl Show for UsePath

    UsePath::equal

    source
    fn UsePath::equal(UsePath, UsePath) -> Bool

    UsePath::not_equal

    source
    fn UsePath::not_equal(x : UsePath, y : UsePath) -> Bool

    UsePath::output

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

    UsePath::to_repr

    source

    UsePath::to_string

    source
    fn UsePath::to_string(self : UsePath) -> String

    VariantCase

    source
    pub struct VariantCase {
      name : String
      ty : TypeExpr?
    } derive(Eq, 
    Debug    )

    impl Show for VariantCase

    VariantCase::equal

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

    VariantCase::not_equal

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

    VariantCase::output

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

    VariantCase::to_repr

    source

    VariantCase::to_string

    source
    fn VariantCase::to_string(self : VariantCase) -> String

    WitFile

    source
    pub struct WitFile {
      pkg : PackageName?
      interfaces : Array[Interface]
      worlds : Array[World]
      packages : Array[WitFile]
    } derive(Eq, 
    Debug    )

    impl Show for WitFile

    WitFile::equal

    source
    fn WitFile::equal(WitFile, WitFile) -> Bool

    WitFile::not_equal

    source
    fn WitFile::not_equal(x : WitFile, y : WitFile) -> Bool

    WitFile::output

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

    WitFile::to_repr

    source

    WitFile::to_string

    source
    fn WitFile::to_string(self : WitFile) -> String

    World

    source
    pub struct World {
      name : String
      docs : String?
      types : Array[TypeDef]
      imports : Array[WorldItem]
      exports : Array[WorldItem]
    } derive(Eq, 
    Debug    )

    impl Show for World

    World::equal

    source
    fn World::equal(World, World) -> Bool

    World::not_equal

    source
    fn World::not_equal(x : World, y : World) -> Bool

    World::output

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

    World::to_repr

    source

    World::to_string

    source
    fn World::to_string(self : World) -> String

    WorldItem

    source
    pub enum WorldItem {
      Interface(UsePath)
      NamedInterface(String, UsePath)
      External(String, WorldItem)
      Function(Function)
      InlineInterface(InlineInterface)
      Include(IncludeDecl)
      Use(UseDecl)
    } derive(Eq, 
    Debug    )

    impl Show for WorldItem

    WorldItem::equal

    source
    fn WorldItem::equal(WorldItem, WorldItem) -> Bool

    WorldItem::not_equal

    source
    fn WorldItem::not_equal(x : WorldItem, y : WorldItem) -> Bool

    WorldItem::output

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

    WorldItem::to_repr

    source

    WorldItem::to_string

    source
    fn WorldItem::to_string(self : WorldItem) -> String

    interface_infos

    source
    fn interface_infos(resolve : Resolve) -> Array[ResolvedInterfaceInfo]

    Build resolved interface infos from Resolve.

    parse

    source
    fn parse(source : String) -> Result[WitFile, ParseError]

    Parse a WIT source string into a WitFile.

    parse_path

    source
    fn parse_path(path : String) -> Result[WitFile, ParseError]

    Parse a WIT file or directory into a WitFile.

    resolve

    source
    fn resolve(source : String) -> Result[Resolve, ParseError]

    Resolve a WIT source string into a Resolve.

    resolve_interface_infos

    source
    fn resolve_interface_infos(source : String) -> Result[Array[ResolvedInterfaceInfo], ParseError]

    Resolve WIT source and return resolved interface infos.

    resolve_multi

    source
    fn resolve_multi(asts : Array[WitFile]) -> Result[Resolve, ParseError]

    Resolve multiple WIT ASTs into a single Resolve.

    resolve_path

    source
    fn resolve_path(path : String, world? : String) -> Result[ResolveInput, ParseError]

    Resolve a WIT file or directory (with deps) into a ResolveInput.

    resolve_path_interface_infos

    source
    fn resolve_path_interface_infos(path : String, world? : String) -> Result[Array[ResolvedInterfaceInfo], ParseError]

    Resolve WIT path and return resolved interface infos.

    tokenize

    source
    fn tokenize(source : String) -> Result[Array[Token], ParseError]

    Source Files