原标题：MoonBit 语言的十大特性（MoonBit Language in 10 Features）

原文链接：https://medium.com/@hivemind_tech/moonbit-language-in-10-features-4dc41a3a1d6c
作者：Ignacio丨德国科技公司 Hivemind 工程师

作为一名Scala开发者，我最近注意到Scala的市场在逐渐萎缩，这促使我探索其他具有类似特性的编程语言，例如支持函数式编程、高阶类型、高阶函数、泛型、运算符重载和领域建模等。

最近，我在 X（前称Twitter）上听说了MoonBit语言，并通过搜索了解了更多信息。MoonBit是一种AI原生的通用编程语言，由张宏波领导开发。

张宏波在编程语言开发方面有着丰富的经验，曾是 OCaml 的核心贡献者，ReScript的创建者，并在 Meta （前称 FaceBook）公司参与了 Flow 的开发。

MoonBit 由粤港澳大湾区数字经济学院（IDEA）开发，该机构致力于人工智能和数字经济领域的前沿研究和产业应用。

在其官方网站上，我发现MoonBit具有以下基本特性：

• 融合了Rust和Scala的优点

• 不使用Rust中的“借用”概念

• 采用垃圾回收机制

• 性能卓越

• 可编译为WebAssembly

为了体验MoonBit的编程感受是否类似于编写高质量的Scala代码，我决定用MoonBit编写一些代码。我选择了一个众所周知的主题进行领域建模：国际象棋棋盘。我希望定义棋子、棋盘以及游戏的初始状态（暂不涉及棋子的移动和游戏逻辑）。

示例代码库可在以下链接找到：https://github.com/ignacio-hivemind/MoonBit-chess-example

接下来，让我们逐一探讨MoonBit的这些特性。

十大特性

1、枚举类型

首先，我为棋盘上的棋子创建了一些定义。在国际象棋中，棋子可以是黑色或白色，种类包括兵（Pawn）、车（Rook）、马（Knight）、象（Bishop）、后（Queen）和王（King）。

// This application is about a chess board,
// and how to represent it in the MoonBit language.
//
// Board is a double dimension array of BoardPlace
// cols:  0 1 2 3 4 5 6 7
// row 0: R N B Q K B N R
// row 1: P P P P P P P P
// row 2: . . . . . . . .
// row 3: . . . . . . . .
// row 4: . . . . . . . .
// row 5: . . . . . . . .
// row 6: p p p p p p p p
// row 7: r n b q k b n r
//
// The upper case letters represent the white pieces,
// whereas the lower case letters represent the black pieces.
// The pieces are: Pawn (P or p), Rook (R or r), Knight (N or n),
// Bishop (B or b), Queen (Q or q), King (K or k).
// The dots represent empty places.


/// This is documentation for the Color enum data type.
/// This is the color of the pieces in a chess game.
pubenumColor {
   White
   Black
}


/// This is documentation for the Piece enum.
/// It represents the different pieces in a chess game.
pubenumPiece {
   Pawn
   Rook
   Knight
   Bishop
   Queen
   King
}

如上所示，在定义前使用三个斜杠（///）可为方法、数据类型或函数添加文档注释。使用两个斜杠（//）则表示单行注释。pub关键字表示这些定义对其他文件或模块是公开的。枚举类型（enum）定义了一种新的类型，其值只能是大括号内指定的选项。例如，Color的值只能是White或Black，Piece的值只能是Pawn、Rook、Knight、Bishop、Queen或King之一。

2、内置Trait的自动派生

在之前的枚举定义中，我们可以添加derive(Show, Eq)，自动为这些枚举实现Show和Eq特性。这意味着我们可以直接比较和打印Color或Piece的实例。

pub enum Color {
..
} derive(Show, Eq)

pub enum Piece {
..
} derive(Show, Eq)

例如，我们可以编写一个函数来比较棋子：

pub enum Color {
    ..
} derive(Show, Eq)

pub enum Piece {
    ..
} derive(Show, Eq)

pub fn compare_pieces(piece: Piece) -> Unit {
    if piece == Pawn {
        println("The piece is a pawn")
    } else {
        println("The piece is a " + piece.to_string())
    }
}

在这个示例中，我们可以直接使用 == 运算符比较Piece的实例，因为Piece实现了Eq特性。同时，我们可以使用to_string()方法打印Piece的实例，因为它实现了Show特性。

3、类型别名

在定义棋盘时，我们可以使用类型别名来提高代码的可读性和可维护性。例如，定义BoardPlace为Option[(Piece, Color)]，表示棋盘上的每个位置要么为空，要么包含一个特定颜色的棋子。

/// This is the representation of a place on a chess board.
/// It can be empty (None) or contain a piece with a color: Some((piece, color)).
pub typealias BoardPlace = Option[(Piece, Color)]

通过这种定义方式，在代码中任何位置，我们都可以用BoardPlace代替对应的Option类型，反之亦然。这只是右侧类型定义的简化表达方式。另外，值得注意的是，Option数据类型内置于MoonBit语言的标准库中，与Rust和Scala类似。MoonBit还内置了Result数据类型，它与Scala中的Either类型类似，但更专注于错误处理。

4、模式匹配

模式匹配(Pattern Matching) 对熟悉Haskell、Scala或Rust的开发者而言，“模式匹配”是一个常见概念。在MoonBit中，可以通过如下方式定义一个使用模式匹配的函数：

fn draw(self: BoardPlace) -> String {
    match self {
        None => "." // empty place
        Some((piece, Color::White)) => pieceToString.get*or_default(piece, ".")
        Some((piece, Color::Black)) => pieceToString.get_or_default(piece, ".").to_lower()
    }
}

这里，pieceToString是一个映射(map)：

let pieceToString: Map[Piece, String] = Map::of([
    (Piece::Pawn, "P"),
    (Piece::Rook, "R"),
    (Piece::Knight, "N"),
    (Piece::Bishop, "B"),
    (Piece::Queen, "Q"),
    (Piece::King, "K")
])

上述函数的输入是BoardPlace类型，输出则是表示棋盘上该位置棋子的字符串。此外，你还可以使用特殊的通配符 *，来匹配所有未被前面的模式匹配到的其他情况。

需要注意的是，在MoonBit中，match 和 if 关键字都是表达式（expressions），而非语句（statements）。因此，它们会返回一个值。

与Scala类似，在一个由花括号 {} 围成的代码块中，最后一个表达式的值即为该代码块的返回值。这一点在函数中同样适用，例如：

pub fn abs(a: Int) -> Int {
    let absolute: Int = if a >= 0 { a } else { -a }
        return absolute
}

当省略掉return关键字时，也能达到完全相同的效果：

pub fn abs(a: Int) -> Int {
    let absolute: Int = if a >= 0 { a } else { -a }
    absolute
}

然而，在某些场景中，使用显式的return语句仍然是非常有用的，特别是当你希望提前返回（early return），跳过函数剩余逻辑处理特定情况时：

pub fn early_return(a: String) -> Bool {
    if a == "." {
        return false
}

// go on with the function logic:
// at this point you know that a is NOT “.”
// ...
}

5、结构体类型

结构体（struct）类型允许通过组合多个不同类型的字段来构造出新的数据类型。这种机制类似于其他编程语言中的类（class），特别是在结构体中加入方法定义以及信息隐藏（封装）时，更是如此。

例如，我们可以这样定义棋盘上的一行（Row）：

/// This is a struct that represents a row in the board
pub struct Row {
    // Array type definition:
    priv cols: Array[BoardPlace] // information hiding: private fields
} derive(Show, Eq)

再定义整个棋盘（Board）的网格结构以及棋盘当前的状态（BoardState）：

/// This is a struct that represents the board grid
pub struct Board {
    priv grid: Array[Row]
}

/// This is a struct that represents the board state
pub struct BoardState {
    priv board: Board
    priv turn: Turn
}

以上定义清晰地表达了棋盘元素及棋盘状态的结构。

当我们想在Row这个结构体的命名空间（namespace）下添加方法时，有两种方式：

方法一： 此方法定义了一个没有任何棋子的棋盘行。注意 Row:: 这个前缀，它明确表明这是针对类型Row定义的方法。

pub fn Row::empty_row() -> Row {
    { cols: Array::make(8, None) }
}

方式二： 如果方法需要访问结构体自身（self）的数据，定义方式则如下：

// fn <name>(self: <type>, <parameters>) -> <return type> { <body> }
// And then you can call: <object>.<name>(<parameters>)
pub fn get_turn(self: BoardState) -> Turn {
    self.turn
}

例如，当board_state是BoardState类型的实例时，我们就可以通过 board_state.get_turn() 来获取当前国际象棋游戏中的回合（Turn）信息。

6、运算符重载

可以通过重载“[]”运算符，以允许对棋盘行中的元素进行索引操作，如下面的代码片段所示。你只需为你的类型（在本例中为Row类型）重载**op_get()**方法即可：

// This special method name "op_get" is used to overload the [] operator.
pub fn op_get(self:Row, index: Int) -> BoardPlace {
    self.cols[index]
}To allow for indexed assignment operations, you can override the op_set() method:

为了允许索引赋值操作，你还可以重载 op_set() 方法：

pub fn op_set(self: Row, index: Int, value: BoardPlace) -> Unit {
    self.cols[index] = value;
}

例如，现在你可以这样做：

pub fn check_first_element(row: Row) -> Unit {
    let element: BoardPlace = row[0] // Access the row with an index using “[]” operator
    if element is Some((Piece::Pawn, Color::White)) {
   println("First element is a white pawn")
 }
 ...
}

7、新类型定义

MoonBit允许你基于已有的类型定义一个新类型。例如，要定义Turn数据类型，我们可以这样做：

/// This is a new type that represents a turn in a chess game.
pub type Turn Color

现在，Turn就是一个新类型，类似于Scala语言中的opaque类型。要创建一个Turn类型的实例，你需要将值包装在类型名中：

pub fn BoardState::initialSetup!() -> BoardState {
    { board: Board::initialize!(), turn: Turn(Color::White) }
}

这种方式确保了颜色（Color）和回合（Turn）的值在编译时不会被混淆。

8、特性

下面是MoonBit中定义新特性的语法。由于它是“open”的，因此可以被扩展：

/// This trait defines a draw method that returns a string
/// representation of the object.
/// It is used to draw the different objects in the chess game to a String.
/// (although it could be in another format or different resource, like a file or
/// screen).
pub(open) trait Drawable {
    draw(Self) -> String
    }

    pub(open) trait Paintable {
        paint(Self) -> Unit
    }

我们定义了两个特性，每个特性中都有不同的（抽象）方法：draw() 和 paint()。这类似于 Java 中的接口或 Scala 中的 trait。

两个特性可以通过“+”运算符进行组合或继承：

// This is how you extend and combine traits in MoonBit language.
pub trait DrawableAndPaintable : Drawable + Paintable {}

特性中的方法通过以下方式进行实现：

/// Implement Drawable for BoardPlace trait
pub impl Drawable for BoardPlace with draw(self: BoardPlace) -> String {
    ...
}

如你所见，我在 BoardPlace 类型上实现了 draw() 方法（以满足 Drawable 接口的要求）。如果我们同样为 BoardPlace 类型实现** paint() ** 方法，那么该数据类型也将满足** Paintable ** 和 DrawableAndPaintable 。

接下来，我们还可以为 Row 类型实现 draw() 方法：

/// Implement Drawable for Row
impl Drawable for Row with draw(self: Row) -> String {
    ...
}

9、内置测试

通过定义一个辅助函数，我们可以根据字符串生成一行新的棋盘数据：

pub fn Row::new_row_from_string!(rowStr: String) -> Row {
    assert_eq!(rowStr.length(), 8)
    let cols = []
    // for loops in MoonBit
    for i in 0..=7 {
        cols.push(new_place_from_char(rowStr[i]))
    }
    { cols: cols }
}

这是在 MoonBit 中定义 for 循环的方式，用于从 0 到 7（包含7）进行迭代。我将输入字符串中的每个棋子依次插入到 cols 数组中。assert_eq! 语句用于检查 rowStr 参数的长度是否为 8，以确保可以正确构造出一行。最后一行返回一个新的 Row 对象。

接下来，我们可以在代码的任何位置使用 test 关键字定义测试：

test "create a white row from string" {
    let my_row: Row = Row::new_row_from_string!("RNBQKBNR")

    assert*eq!(my_row[0], Some((Piece::Rook, Color::White)))
    assert_eq!(my_row[1], Some((Piece::Knight, Color::White)))
    assert_eq!(my_row[2], Some((Piece::Bishop, Color::White)))
    assert_eq!(my_row[3], Some((Piece::Queen, Color::White)))
    assert_eq!(my_row[4], Some((Piece::King, Color::White)))
    assert_eq!(my_row[5], Some((Piece::Bishop, Color::White)))
    assert_eq!(my_row[6], Some((Piece::Knight, Color::White)))
    assert_eq!(my_row[7], Some((Piece::Rook, Color::White)))
}

这种方式非常简洁，我们无需依赖其他测试框架，就可以直接在代码中嵌入测试块，用来验证某些性质是否一直成立，特别是在持续开发新功能或重构代码时非常有帮助。

10、函数式编程支持

让我们回顾上一节中定义的 new_row_from_string() 函数。我们原本使用** for** 循环逐个将棋子压入行数组中，但其实可以使用数组的 map 函数来生成这些元素：

pub fn Row::new_row_from_string!(rowStr: String) -> Row {
    assert_eq!(rowStr.length(), 8)
    { cols: rowStr.to_array().map(new_place_from_char) }
}

现在，它变成了一行搞定！

这个函数的逻辑是：将字符串转换为字符数组，然后逐个字符传入 new_place_from_char() 函数，用以生成 cols 数组。最后的表达式构造并返回一个包含 cols 的结构体实例。

另外，作为一个额外的特性，MoonBit 支持泛型数据类型，你可以用它来定义集合或参数化类型：

fn count[A](list : @immut/list.T[A]) -> UInt {
    match list {
        Nil => 0
        Cons(*, rest) => count(rest) + 1
    }
}

更多关于泛型和函数式编程的细节将在后续文章中介绍！

优势

1、垃圾回收

MoonBit 是一种表达能力非常强的语言，在许多方面与 Rust 相似，但不采用 Rust 中“借用”和“所有权”的内存管理概念。虽然这些机制能带来内存安全，但在我看来它们太底层、使用起来也不够友好。而 MoonBit 使用的是垃圾回收机制来回收内存空间，这使得语言对开发者更友好，编码体验也更加简洁自然。

2、工具链

本次示例我只写了大约 400 行代码，但用来运行和测试程序的工具（如 moon 命令行工具）以及 VS Code 插件，给我的感觉是相当稳定、实用，能够很好地支持大型应用的开发。唯一的不足是调试器有时会显示局部变量的内部表示形式，而不是它们实际的值，这不太直观。

3、性能表现

虽然我只用 MoonBit 编程了几个小时，但它的编译和运行速度都非常快！编译器主要面向 WASM（WebAssembly）优化，但也支持编译为 JavaScript 和其他平台的代码。

你可以在 MoonBit 官方网站（https://www.MoonBitlang.com/）查看一些性能基准测试：

（此处原文附有链接和图表，建议前往官网获取最新数据）

令人惊讶的是，在一些基准测试中，MoonBit 的表现甚至超过了 Rust 和 Go。MoonBit 能够生成体积紧凑的二进制文件，这在 Web 环境中能显著提升加载速度和运行性能，使部署变得更容易、更快速、更具成本效益。

4、与 Scala 的对比

MoonBit 语言同样吸收了许多来自 Scala 的概念，比如“代码块返回最后一个表达式的值”。

MoonBit 的语言规模更小，也并未包含 Scala 中的所有特性。但考虑到 Scala 的学习曲线陡峭、精通难度较高，这反而可能是件好事——因为这意味着更容易让开发团队快速上手。虽然你不会拥有所有的函数式编程（FP）特性，但依然可以编写出非常不错的函数式代码，例如以下代码片段（摘自 MoonBit 官网）：

fn main {
    resources
        .iter()
            .map*option(fn {
            (name, Text(str)) | (name, CSV(content=str)) => Some((name, str))
            (*, Executable) => None
        })
    .map(fn {
        (name, content) => {
            letname = name.pad*start(10, ' ')
            letcontent = content
                .pad_end(10, ' ')
                .replace_all(old="\n", new=" ")
                .substring(start=0, end=10)
            "\{name}: \{content} ..."
        }
    })
    .intersperse("\n")
    .fold(init="Summary:\n", String::op_add)
    |> println
}

你可以使用 Lambda 表达式、特性（traits）、结构体（structs，代替类）以及高阶函数。此外，就像在 Rust 和 Scala 中一样，MoonBit 也内建了 Option 和 Result 数据类型。Scala 在表达能力和灵活性方面更强，但也更复杂。

Scala 还能调用所有 Java 的库——这些库经过多年发展，数量庞大且非常稳定；相比之下，MoonBit 当前可用的库数量不多，成熟度也相对较低（在官方网站上，大约有 250 个左右的库可供使用）。

Moon CLI 也作为包管理器使用，例如：moon add peter-jerry-ye/async。这条命令告诉项目添加一个名为 peter-jerry-ye/async 的依赖项。

5、社区

MoonBit 的社区规模尚不如 Rust 或 Scala，那意味着目前在网上找资料会比较困难，AI 编程助手（如 LLM 和 Copilot）对 MoonBit 的支持也还不够完善。

起初，我认为这个语言还非常不成熟，但当我在 https://mooncakes.io/ 上查看其可用库时，发现其实 MoonBit 已经涵盖了许多基础领域的库，例如 HTTP、异步编程、机器学习工具（如 torch）等。

此外，MoonBit 还内置了 Json 数据类型，这对于开发需要处理 HTTP JSON 服务的程序员来说非常实用：

fn main {
    let json_example : Json = {
        "array": ["a", "b"],
        "age": 22,
        "name": "John",
        "boolean": True
    }
    let greeting = match json_example {
        { "age": Number(age), "name": String(name) } => "Hello \{name}. You are \{age}"
        * => "not match"
    }
    greeting |> println
}

最后总结

截至2025年3月，MoonBit 已经超越测试阶段。其编译器（包括 WebAssembly 后端）已于2024年12月开源，这标志着向稳定版本迈出了重要一步。MoonBit 团队正在稳步推进 1.0 正式版的发布，预计将包括对异步支持和嵌入式编程能力的集成。

凭借其现代化的语言特性、高性能以及生成的二进制文件体积小，MoonBit 在部署到云端时非常轻便且成本低。

尽管 MoonBit 的表达能力不如 Scala 丰富、简洁，因此暂时还不能完全取代 Scala，但它目前在很多方面可以与 Rust 相抗衡。这使得 MoonBit 在某些商业领域具备强大的成功潜力。

MoonBit（https://www.moonbitlang.cn/）是国内首个工业级编程语言及其配套工具链，由粤港澳大湾区数字经济研究院（简称“IDEA 研究院”）基础软件中心打造的 AI 原生的编程语言以及开发者平台。通过创新框架在程序语言界形成后发优势，在编译速度、运行速度、体积大小上已成功领先传统语言。