🥮 mooncakes.io

wit

WIT parser and resolver in MoonBit

wit
wasm
component
moon add mizchi/wit@0.3.2
Download zip
Author
Version
0.3.2
License
Apache-2.0
Repository
Last updated
17 hours ago
Downloads
63K

Dependencies

README

#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

#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

#
Field

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

impl Show for Field

#
Function

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

impl Show for Function

#
FunctionKind

source
pub enum FunctionKind {
  Freestanding
  Constructor(String)
  Method(String)
  Static(String)
} derive(Eq, 
Debug)

#
IncludeDecl

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

impl Show for IncludeDecl

#
IncludeRename

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

#
InlineInterface

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

#
Interface

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

impl Show for Interface

#
InterfaceItem

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

#
PackageName

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

impl Show for PackageName

#
Param

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

impl Show for Param

#
RFunction

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

Function definition
impl Show for RFunction
impl ToJson for RFunction

#
RFunctionKind

source
pub enum RFunctionKind {
  Freestanding
  Constructor(Int)
  Method(Int)
  Static(Int)
} derive(Eq, 
Debug)

Function kind

#
RHandleKind

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

impl Show for RHandleKind

#
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

#
RInterfaceRef

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

#
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

#
RPackageName

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

#
RRecordField

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

#
RType

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

Resolve type reference
impl Show for RType
impl ToJson for RType

#
RTypeDef

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

impl Show for RTypeDef
impl ToJson for RTypeDef

#
RTypeKind

source
pub enum RTypeKind {
  Record(Array[RRecordField])
  Variant(Array[RVariantCase])
  List(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

#
RTypeOwner

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

impl Show for RTypeOwner

#
RVariantCase

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

#
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

#
RWorldItem

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

World item
impl Show for RWorldItem

#
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

#
ResolveInput

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

#
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)

#
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)

#
Resource

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

impl Show for Resource

#
Token

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

impl Show for Token

#
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

#
TypeDef

source
pub struct TypeDef {
  name : String
  kind : TypeDefKind
  docs : String?
} derive(Eq, 
Debug)

impl Show for TypeDef

#
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

#
TypeExpr

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

impl Show for TypeExpr

#
UseDecl

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

impl Show for UseDecl

#
UsePath

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

impl Show for UsePath

#
VariantCase

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

impl Show for VariantCase

#
WitFile

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

impl Show for WitFile

#
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

#
WorldItem

source
pub enum WorldItem {
  Interface(UsePath)
  Function(Function)
  InlineInterface(InlineInterface)
  Include(IncludeDecl)
} derive(Eq, 
Debug)

impl Show for WorldItem

#
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

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io