Ten Key Features of MoonBit Language with a Chess Board Example

As a Scala developer noticing the shrinking market for Scala, I explored MoonBit, an AI‑native general‑purpose language led by Zhang Hongbo, a former OCaml core contributor and creator of ReScript.

MoonBit is developed by the Guangdong‑Hong Kong‑Macao Greater Bay Area Digital Economy Institute (IDEA) and combines the strengths of Rust and Scala while avoiding Rust’s borrow checker.

The language offers several notable features:

Combines Rust and Scala advantages

Does not use Rust’s borrowing model

Garbage‑collected

High performance

Compiles to WebAssembly

To experience MoonBit, I modeled a chess board, defining pieces, colors, and the initial board state. The source code is available at GitHub .

1. Enum Types

Enums are used to represent piece colors and kinds. Documentation comments use three slashes (///) and single‑line comments use two slashes (//). The pubenum Color { White, Black } and pubenum Piece { Pawn, Rook, Knight, Bishop, Queen, King } definitions illustrate this.

2. Automatic Trait Derivation

Adding derive(Show, Eq) to an enum automatically implements printing and equality, enabling direct comparison of Piece values.

3. Type Aliases

A type alias improves readability: pub typealias BoardPlace = Option[(Piece, Color)] represents a board cell that may be empty or contain a piece with a color.

4. Pattern Matching

Pattern matching works like in Scala or Rust. The draw function matches on BoardPlace to return a string representation, using match as an expression.

5. Struct Types

Structs model rows and the board grid. Example definitions: pub struct Row { priv cols: Array[BoardPlace] } derive(Show, Eq) and pub struct Board { priv grid: Array[Row] } . A BoardState struct holds the board and the current turn.

6. Operator Overloading

The op_get and op_set methods overload the [] operator for indexing rows.

7. New Type Definitions

Opaque‑like types are created with pub type Turn Color , allowing a distinct Turn type.

8. Traits (Features)

Traits define interfaces such as Drawable and Paintable . They can be combined: pub trait DrawableAndPaintable : Drawable + Paintable {} . Implementations are provided for BoardPlace and Row .

9. Built‑in Testing

Tests are written directly in the source using the test keyword, e.g., verifying that a row created from the string "RNBQKBNR" contains the correct pieces.

10. Functional Programming Support

Higher‑order functions, map, and immutable data structures are supported. The new_row_from_string function is refactored to use to_array().map(new_place_from_char) instead of an explicit loop.

Additional advantages of MoonBit include a fast compiler targeting WebAssembly, a stable CLI tool ( moon ), and built‑in Option and Result types. Compared with Scala, MoonBit offers similar functional concepts (e.g., last‑expression return) with a smaller learning curve, though its ecosystem is still growing.

Performance benchmarks show MoonBit can outperform Rust and Go in certain scenarios, producing compact binaries ideal for cloud deployment. The language is AI‑native, supports JSON handling, and provides a package manager via moon add .

In summary, MoonBit combines modern language features, high performance, and a lightweight toolchain, making it a promising choice for developers seeking an expressive, functional language with strong WebAssembly support.