🥮 mooncakes.io

moon-wit

A dependency-free WIT parser and MoonBit API scaffold generator

wit
wasm
component-model
bindgen
codegen
moon add pei0331/moon-wit@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
4 days ago
Downloads
2
README

#pei0331/moon-wit

A WIT core-subset parser and MoonBit API scaffold generator. It emits typed declarations and compiling function stubs. Version 0.1.0 does not yet implement the Component Model Canonical ABI, so the generated functions are not callable Wasm import/export bindings. Design inspired by bytecodealliance/wit-bindgen.

The module has no third-party runtime dependencies beyond MoonBit core.

#Usage

The library exposes the parse → generate pipeline used by the moon-wit CLI:

///|
let pkg = @moon_wit.parse(src) // WIT text → WitPackage (raises WitError)

///|
let bindings = @moon_wit.generate(pkg) // → bindings.mbt content

///|
let moon_pkg = @moon_wit.generate_moon_pkg(
  @moon_wit.needs_list_import(pkg), // → moon.pkg content
)

Checked-in CLI outputs are compiled by CI. They cover inline interfaces, escaped identifiers, direct world-level functions, resources, composition, versioned WASI paths, async scaffold handles and official-style attributes. Versioned external paths such as wasi:io/streams@0.2.0 are preserved across parse/render and code generation. Flags use UInt bitmasks, while future<T> and stream<T> generate opaque typed scaffold handles.

#Public API

  • parse(String) -> WitPackage raise WitError — lex + parse a WIT document.
  • generate(WitPackage) -> String — render MoonBit bindings.
  • needs_list_import(WitPackage) -> Bool — whether list<T> appears.
  • generate_moon_pkg(Bool) -> String — contents of the generated moon.pkg.
  • type_str(WitType) -> String — WIT type → MoonBit type.
  • type_name / case_name / field_name — kebab-case → Pascal/snake_case.

Errors carry 1-based line:column positions. The implementation is pure logic with no I/O, so the lexer/parser/codegen run unchanged on the Wasm targets; file I/O lives only in the moon-wit CLI (cmd/moon-wit).

#
WitError

source
pub(all) suberror WitError {
  At(Int, Int, String)
}

A lexer/parser error with 1-based line and column position.

#
WitError::make

source
fn WitError::make(line : Int, col : Int, message : String) -> WitError

#
WitError::to_string

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

Formats as line:col: message.

#
Case

source
pub struct Case {
  name : String
  ty : WitType?
}

A variant case. ty is None for a unit case.

#
Case::to_string

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

#
Field

source
pub struct Field {
  name : String
  ty : WitType
}

A named field with its type (record field or function parameter).

#
Field::to_string

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

#
FuncResult

source
pub enum FuncResult {
  Unnamed(WitType)
  Named(Field)
}

A single unnamed result, or a named result (WIT named results).

#
FuncResult::to_string

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

#
FuncSig

source
pub struct FuncSig {
  name : String
  params : Array[Field]
  results : Array[FuncResult]
}

A func signature with parameters and results.

#
FuncSig::to_string

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

#
ImpExp

source
pub struct ImpExp {
  name : String
  asName : String?
  inline : Interface?
}

An import foo [as bar] [: interface {...}] or export ... item.

#
ImpExp::to_string

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

#
Interface

source
pub struct Interface {
  name : String
  items : Array[InterfaceItem]
}

An interface definition.

#
Interface::to_string

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

#
InterfaceItem

source
pub enum InterfaceItem {
  Use(UseDecl)
  Type(TypeDef)
  Func(FuncSig)
}

An item inside an interface (or an inline interface in a world).

#
InterfaceItem::to_string

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

#
ResourceFunc

source
pub struct ResourceFunc {
  kind : ResourceFuncKind
  sig : FuncSig
}

#
ResourceFuncKind

source
pub enum ResourceFuncKind {
  Constructor
  Static
  Method
}

#
Token

source
pub struct Token {
  kind : TokenKind
  line : Int
  col : Int
} derive(Eq)

#
Token::to_string

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

#
TokenKind

source
pub enum TokenKind {
  Ident(String)
  Version(String)
  LBrace
  RBrace
  LParen
  RParen
  Lt
  Gt
  Comma
  Semi
  Colon
  Arrow
  Eq
  Dot
  Slash
  At
  Star
  Eof
} derive(Eq)

#
TypeDef

source
pub struct TypeDef {
  name : String
  kind : TypeDefKind
}

A named type definition.

#
TypeDef::to_string

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

#
TypeDefKind

source
pub enum TypeDefKind {
  Record(Array[Field])
  Variant(Array[Case])
  Enum(Array[String])
  Flags(Array[String])
  Resource(Array[ResourceFunc])
  Alias(WitType)
}

The kind of a named type definition.

#
UseDecl

source
pub struct UseDecl {
  path : String
  names : Array[UseName]
}

use <path>.{a, b as c} — re-exports types from an interface.

#
UseDecl::to_string

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

#
UseName

source
pub struct UseName {
  name : String
  asName : String?
}

use path.{a, b as c} declaration.

#
UseName::to_string

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

#
WitItem

source
pub enum WitItem {
  Interface(Interface)
  World(World)
  Use(UseDecl)
}

An item at the top level of a WIT document.

#
WitItem::to_string

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

#
WitPackage

source
pub struct WitPackage {
  ns : String
  name : String
  version : String?
  items : Array[WitItem]
}

A parsed WIT document (the result of parse).

#
WitPackage::to_string

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

#
WitType

source
pub enum WitType {
  Name(String)
  U8
  U16
  U32
  U64
  S8
  S16
  S32
  S64
  F32
  F64
  TChar
  TString
  TBool
  List(WitType)
  Option(WitType)
  Result(WitType?, WitType?)
  Tuple(Array[WitType])
  Own(String)
  Borrow(String)
  Future(WitType?)
  Stream(WitType?)
}

A reference to a WIT type.

#
WitType::to_string

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

Renders a WIT type reference back to WIT syntax.

#
World

source
pub struct World {
  name : String
  items : Array[WorldItem]
}

A world definition.

#
World::to_string

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

#
WorldItem

source
pub enum WorldItem {
  Import(ImpExp)
  Export(ImpExp)
  ImportFunc(FuncSig)
  ExportFunc(FuncSig)
  Include(String, Array[UseName])
  Use(UseDecl)
}

An item inside a world.

#
WorldItem::to_string

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

#
case_name

source
fn case_name(name : String) -> String

first-name → FirstName (MoonBit enum case naming).

#
field_name

source
fn field_name(name : String) -> String

first-name → first_name (MoonBit field/function naming).

#
generate

source
fn generate(pkg : WitPackage) -> String

Generate the contents of a bindings.mbt file for pkg.

#
generate_moon_pkg

source
fn generate_moon_pkg(use_list : Bool) -> String

Contents of the moon.pkg for a generated package.

#
needs_list_import

source
fn needs_list_import(pkg : WitPackage) -> Bool

Whether any generated type needs moonbitlang/core/list.

#
parse

source
fn parse(src : String) -> WitPackage raise WitError

Parse a WIT document into a [WitPackage].

#
tokenize

source
fn tokenize(src : String) -> Array[Token] raise WitError

Tokenize a full WIT document. Raises WitError on an unexpected character or an unterminated block comment.

#
type_name

source
fn type_name(name : String) -> String

hello-world → HelloWorld (MoonBit type/case naming).

#
type_str

source
fn type_str(t : WitType) -> String

WIT type → MoonBit type.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io