01 MoonBit 更新​

1. moonbitlang/core 开源​

moonbitlang/core（MoonBit标准库）现已开源。我们很高兴收到社区的积极反馈，想了解更多与moonbitlang/core开源的详情，可点击这里查看：国人自主研发的编程语言 MoonBit Core 开源啦！

Github链接：

https://github.com/moonbitlang/core

2. 支持带标签/可选参数​

支持带标签参数（labelled argument）和可选参数（optional argument）。带标签参数有助于区分相同类型，不同功能的函数：

fn greeting(~name: String, ~location: String) {
  println("Hi, \\(name) from \\(location)!")
}

fn init {
  greeting(~name="somebody", ~location="some city")
  let name = "someone else"
  let location = "another city"
  greeting(~name, ~location)// `~label=label` 可以简写成 `~label`
}

可选参数必须带标签，并且指定默认值。在函数调用的时候，如果没有手动指定参数，则取默认值。注意：默认值在每次调用的时候都会被重新求值：

fn greeting(~name: String, ~location: Option[String] = None) {
  match location {
    Some(location) => println("Hi, \\(name)!")
    None => println("Hi, \\(name) from \\(location)!")
  }
}

fn init {
  greeting(~name="A")// Hi, A!
  greeting(~name="B", ~location=Some("X")// Hi, B from X!
}

3. 提供了内建类型 SourceLoc​

SourceLoc，表示源码中的位置。假如某个函数声明了一个类型为 SourceLoc、默认值为 _ 的可选参数，那么每次调用这个函数时，MoonBit 会自动插入调用处的位置作为这个参数的默认值：

fn f(~loc : SourceLoc = _) {
  println("called at \\(loc)")
}

fn g(~loc : SourceLoc = _) {
  f()// 显示 `g` 内部的位置
  f(~loc)// 自动注入的参数也可以手动覆盖。这一次调用会显示 `g` 的调用者的位置
}

test "source loc" {
  g()
}

在 try.moonbitlang.cn 新建一个名为 test.mbt 的文件，放入上述代码，并运行代码中的测试，可以得到如下的输出：

test source loc ...
called at memfs:/sample-folder/test.mbt:6:3-6:6
called at memfs:/sample-folder/test.mbt:11:3-11:6

SourceLoc 可以用于编写测试相关的函数，用于在测试失败时输出有用的位置信息：

fn assert_eq[X: Eq + Show](result: X, expect: X, ~loc : SourceLoc = _) -> Result[Unit, String] {
  if (result == expect) {
    Ok(())
  } else {
    Err("\\(loc): Assertion failed: \\(result) != \\(expect)")
  }
}

test "1 =? 2" {
  assert_eq(1, 2)?
}

running 1 tests
test 1 =? 2 ... FAILED memfs:/sample-folder/test.mbt:10:3-10:18: Assertion failed: 1 != 2

test result: 0 passed; 1 failed

4. === 已经弃用，可以使用 physical_equal 作为代替​

5. 添加新的内置类型 UnsafeMaybeUninit[T]​

添加新的内置类型 UnsafeMaybeUninit[T] 和对于该类型的一些相关操作，用以在 MoonBit Core 中实现 Vector 等数据结构，因为其不安全性，普通的 MoonBit 程序中应尽可能避免使用该类型。

02构建系统更新​

1. 支持 JavaScript 后端​

可以通过 --target js 来生成后端代码。例如：

a. 通过 moon new hello 新建一个名为 hello 的项目

b. 在 main/main.mbt 中写入：

fn main {
  println("Hello from JavaScript!")
}

c. 在命令行中构建生成 JavaScript 代码，并使用 Node 运行。

$ moon build --target js
moon: ran 2 tasks, now up to date
$ node target/js/release/build/main/main.js
Hello from JavaScript!

d. 你也可以方便地通过 moon run main --target js 来编译并运行编译到 JavaScript 的 MoonBit 代码。

$ moon run main --target js
Hello from JavaScript!

2. 修复了一些 moonbuild 的问题​

a. 修复了 Windows 上 moon upgrade 失败的问题。

b. 修复了 moon add 添加新版本没有移除旧版本的问题。

c. 修复了本地 moon check 失败仍然能够 publish 的问题。

IDE更新​

1. 线上 IDE 支持通过 CodeLens 的方式运行测试​

2. 大幅度改善 moonfmt 的对于包含注释的源代码的处理。​

3. 提升 IDE 和 VSCode 插件的稳定性和用户体验​

a. VSCode插件现在是在文件更改的时候调用moon check而非启动moon check -w。

b. 提升了多行字符串和文档注释（docstring）的输入体验。现在在多行字符串/文档注释内部换行会自动补上 #| 或者 /// 的前缀。

c. 修复了 hover、moon.pkg.json 出错，空文件等导致 lsp 报错的问题。

工具链更新​

Markdown linter 支持 expr 标签​

举个例子：

```moonbit expr
1 * 2 + 3

可以在运行 mdlint 的时候看到对应的输出：

5

一、MoonBit更新​

1. 添加了 += 系列语句​

包括+=、-=、*=、/=，支持运算符重载：

fn init {
  let array = [1,2,3,4]
  array[2] *= 10
  println(array) // [1, 2, 30, 4]
}

fn init {
  let mut a = 1
  a += 20
  println(a) // 21
}
struct Foo {
  data : Array[Int]
} derive(Debug)

fn op_set(self : Foo, index : Int, value : Int) {
  self.data[index] = value
}

fn op_get(self : Foo, index : Int) -> Int {
  self.data[index]
}

fn init {
  let foo : Foo = { data: [0,0,0,0] }
  foo[2] -= 10
  debug(foo) // {data: [0, 0, -10, 0]}
}

2. 现在 toplevel 如果没有顶格会报错​

如下图所示：

3. 引入 super-trait 机制​

Super-trait 通过如下的语法指定：

trait A {
  // ...
}

trait B : A { // A is a super trait of B, B is a sub trait of A
  // ...
}

可以通过 + 来指定多个 Super-trait，表示该 sub-trait 依赖这几个 super-trait：

// ...

trait B: A + Compare + Debug {
  //       ^~~ B is a sub-trait of A *and* Compare *and* Debug
  // ...
}

在使用上，可以将 sub-trait 当作 super trait 使用，但是不能够将 super-trait 当作 sub-trait 使用。目前Compare是Eq的 sub-trait，意味着实现了Compare的类型能够在要求Eq的情况下使用，所以以这两个代码为例：

trait Eq {
  op_equal(Self, Self) -> Bool
}

trait Compare: Eq {
  compare(Self, Self) -> Int
}

fn eq[X: Compare](this: X, that: X) -> Bool {
  this == that
}
fn compare[X: Eq](this: X, that: X) -> Int {
  this.compare(that)
  //   ^~~~~~~ Type X has no method compare.
}

4. 添加T::[x, y, ...]的语法​

这种语法结构会被解糖成T::from_array([x, y, ...])的形式。这种语法使得列表等线性数据结构的初始化更加易读。

enum List[X] {
  Nil
  Cons(X, List[X])
} derive(Show, Debug)

fn List::from_array[X](array: Array[X]) -> List[X] {
  let mut list = List::Nil
  for i = array.length() - 1; i >= 0; i = i - 1 {
    list = Cons(array[i], list)
  }
  list
}

fn main {
  println(List::[1, 2, 3])
}

输出：

Cons(1, Cons(2, Cons(3, Nil)))

5. 调整自动生成的 Show 的实现的逻辑​

现在它会调用 Debug 作为实现。这意味着，现在 derive(Show) 之前需要先 derive 或自行实现 Debug。Debug 的输出是 MoonBit 语法下合法的值，而 Show 可以用于输出更美观的内容。这修复了之前 derive(Show) 在有 String 的结构体上的错误行为：

struct T {
  x: String
} derive(Show, Debug)

fn init {
  println({ x: "1, y: 2" })
  // 之前: {x: 1, y: 2}
  // 现在: {x: "1, y: 2"}
}

6. 目前已不支持fn hello() = "xx"的语法​

fn hello() = "xx"的语法目前已经不适用了。我们建议用户这样写：

extern "wasm" fn hello () =
  #| ...

现在 inline stubs 只支持 wasmgc，不支持 wasm1。

7. 现在丢弃非 Unit 的值会直接报错，如果需要丢弃需要显式使用 ignore。​

fn f() -> Int {
  ignore(3)   // Ok.
  3 |> ignore // Ok.
  3           // Err: Expr Type Mismatch: has type Int, wanted Unit
  3           // Ok, as this value is returned, not dropped
}

8. 移除了test作为标识符使用的支持​

二、IDE更新​

1. 提供更好的线上 IDE Markdown 支持​

• 可以在线上 IDE 中使用 Marp 插件来查看之前现代编程思想课的内容了。

• Markdown 中内嵌的 MoonBit 的代码块支持语法高亮。

• 针对内嵌有 MoonBit 代码的 Markdown 文本开发了语法检查的程序，开源在：GitHub链接。使用方法可以参考项目的 README。

三、构建系统更新​

1. 添加 main 函数的支持​

• main只能写在main包（is_main: true的包）里
• main 包中应当有且仅有一个main 函数
• main函数的执行顺序在所有init函数之后
• main包中不能有test

2. 目前可以通过 moon upgrade 升级 MoonBit 工具链的版本了。​

p.s. 但是在使用之前，必须再用安装脚本安装一次:-)

3. moon check|build|run 现在默认链接到 moonbitlang/core。​

MoonBit 更新​

1. 支持云原生调试功能​

现在，你可以通过访问 try.moonbitlang.cn，直接在浏览器中使用 devtools 调试 MoonBit 程序，无需安装任何软件。具体的使用步骤如下：

2. MoonBit 支持使用 for 关键字定义的函数式循环控制流​

MoonBit 现在支持使用 for 关键字定义的函数式循环控制流，其性能接近于 C/C++ 等底层语言，比如 fib 函数可以写成如下形式：

fn fib( n : Int ) -> Int {
    for i = 0, a = 1, b = 2
        i < n
        i = i + 1, a = b, b = a + b {
    } else { b }
}

MoonBit 的 for 循环可以作为表达式返回一个值，比如上述程序中在循环结束后使用 b 作为整个 for 循环的值，也可以在 for 的循环体中通过 break 提前返回，比如：

fn exists(haystack: Array[Int], needle: Int) -> Bool {
  for i = 0; i < haystack.length(); i = i + 1 {
    if haystack[i] == needle {
      break true
    }
  } else {
    false
  }
}

此外，在 for 循环中可以像传统语言一样使用 continue 进入下一次循环，MoonBit 额外提供了带参数的 continue 来指定下一次循环过程中循环变量的值，比如:

fn find_in_sorted[T](xs: Array[(Int, T)], i: Int) -> Option[T] {
  for l = 0, r = xs.length() - 1; l < r; {
    let mid = (l + r) / 2
    let k = xs[mid].0
    if k == i {
      break Some(xs[mid].1)
    } else if k > i {
      continue l, mid
    } else {
      continue mid + 1, r
    }
  } else {
    None
  }
}

在不需要返回值的情况下，else 分支可以省略，比如：

fn print_from_0_to(n: Int) {
  for i = 0; i <= n; i = i + 1 {
    println(i)
  }
}

3. Inline test 改进​

测试的返回类型从Unit改成了Result[Unit,String]，用于表示测试的结果：

 test "id" {
      if (id(10) != 10) { return Err("The implementation of `id` is incorrect.") }
    }

编译器会自动将test "id" {...} 的语句块{...}使用Ok()包裹起来。因此，当语句块的类型为Unit并且没有提前return时，表示inline test测试通过。配合问号操作符，可以让测试变得更加优雅：

fn id(x : Int) -> Int {
     x + 1 // incorrect result
   }

   fn assert(x : Bool, failReason : String) -> Result[Unit,String] {
     if x { Ok(()) } else { Err(failReason) }
   }

   test "id" {
     assert(id(10) == 10, "The implementation of `id` is incorrect.")?
   }

执行moon test，输出如下：

➜  my-project moon test
running 1 tests in package username/hello/lib
test username/hello/lib::hello ... ok

test result: 1 passed; 0 failed

running 1 tests in package username/hello/main
test username/hello/main::id ... FAILED: The implementation of `id` is incorrect.

test result: 0 passed; 1 failed

Hello, world!

4. 改进 VS Code 插件的函数签名提示，现在会显示参数名：​

5. 改进了 VS Code 插件对 core 包开发的支持​

6. moon new 支持快速创建新项目​

• moon new hello 在文件夹 hello 中创建一个名为 username/hello 的可执行项目
• moon new hello --lib 在文件夹 hello 中创建一个名为 username/hello 的模块

MoonBit更新​

1. 增加了functional for loop控制流支持​

与传统的命令式for loop 不同，循环变量是不可变的。这样的设计将来也容易抽取出来做形式化验证:

fn init {
  for i = 0; i < 5; i = i + 1 {
    debug(i)
    // i = i + 4  error: The variable i is not mutable.
  }
}

输出：

01234

functional for loop也支持多个绑定。与其他语言不同的是，x和y在functional for loop的第三个表达式里具有同时更新的语义：

fn init {
  for x = 0, y = 0; x < 10; x = x + 1, y = x + 1 {
                                        // ^~~ 这里x的值是更新前的
    println("x: \(x), y: \(y)")
  }
}

输出：

x: 0, y: 0
x: 1, y: 1
x: 2, y: 2
x: 3, y: 3
x: 4, y: 4
x: 5, y: 5
x: 6, y: 6
x: 7, y: 7
x: 8, y: 8
x: 9, y: 9

functional for loop内部也支持使用break和continue。

fn init {
  let xs = [0,1,2,3,4,5,6,7,8]
  let mut sum = 0
  for i = 0, v = xs[0]; i < xs.length(); i = i + 1, v = xs[i + 1] {
    if v % 2 == 0 { continue }
    if v >= 7 { break }
    sum = sum + v
  }
  debug(sum) //output： 9
}

2. 改进moon new创建项目的向导​

现在可以用方向键选择创建lib或者exec项目:

3. IDE支持管道运算符的智能补全​

对于第一个参数类型与管道左侧表达式类型相等的函数，会放在补全列表的顶部，其它的补全选项仍然会显示在列表后。

4. 根据社区反馈调整了pipe表达式​

现在管道运算符右侧支持Double::to_int这样的函数调用。

fn init {
  debug(3.14 |> Double::to_int) // output: 3
  debug(4 |> Array::make('c')) // output: ['c', 'c', 'c', 'c']
}

5. 修复IDE中缀表达式错误地插入inlay hint的问题​

MoonBit 更新​

1. 新增多行字符串支持​

每行需要以#|开头。多行字符串每行之间允许断开、插入注释，字符串内不支持转义和字符串插值。

2. 新增函数式的loop循环​

其中continue 只允许出现在尾递归调用的位置，loop内允许使用break提前返回一个值。

3. 提供Trait::method调用支持​

支持以Debug::debug_write(self, buf)的形式调用trait method

4. 添加实验性标准库机制​

最新的安装脚本会将标准库下载到 ~/.moon/lib/core 目录下。目前标准库的内容以及相关IDE支持暂不稳定，因此构建系统默认不链接标准库。对于想要提前体验标准库功能的开发者们，可以在 moon check|build|run|test 命令后添加 --std 选项用于链接标准库到当前项目。

5. 支持隐式到trait object的转换​

在上下文中明确需要一个trait object时，会自动插入 as SomeTrait。例如下面的代码：

现在我们可以省略as Debug：

6. 支持函数参数的inlay hint​

7. 字符串和char字面量支持unicode转义、十六进制转义和八进制转义​

MoonBit更新​

1. 新增特性Trait object：​

能够显式地将类型不同但实现相同trait的值装箱并表示成同一个类型，实现函数的动态分发。

fn get_show_list() -> List[Show] {
  let a = 42 as Show
  let b = "xxx" as Show
  let c = 3.14 as Show
  List::Cons(a, Cons(b, Cons(c, Nil)))
}

fn init {
  fn print_show_list {
    List::Cons(a, rest) => { println(a); print_show_list(rest) }
    List::Nil => ()
  }
  print_show_list(get_show_list())
}

2. 新增管道运算符​

提供类似于链式调用的语法，可以串联多个连续的函数调用，省去let name = ...的代码。例如value |> func1(arg1,arg2) |> func2 相当于:

let a = value
let b = func1(a, arg1, arg2)
func2(b)

另一个例子：

fn sub2(x : Int, y : Int) -> Int {
  x - y
}

fn sum3(x : Int, y : Int, z : Int) -> Int {
  x + y + z
}

fn init {
  6 |> sub2(5) |> sum3(1,2) |> println()
}

3. 字符串支持使用\xFF进行十六进制转义​

fn init {
  let data = "\x48\x65\x6c\x6c\x6f"
  println(data) //output: Hello
}

4. Inline test变更​

现在test mode也会执行fn init，执行顺序在inline test之前。

5. Moonfmt：改进类型和长数组字面量的缩进​

原代码：

改进前的格式化效果：

改进后的格式化效果：

MoonBit更新​

1. 新增矩阵函数的语法糖​

新增矩阵函数的语法糖，用于方便地定义局部函数和具有模式匹配的匿名函数：

fn init {
  fn boolean_or { // 带有模式匹配的局部函数
    true, _ => true
    _, true => true
    _, _    => false
  }
  fn apply(f, x) {
    f(x)
  }
  let _ = apply(fn { x => x + 1 }, 42) // 匿名函数
  let _ = apply(fn {                   // 带有模式匹配的匿名函数
    0 => 0
    1 => 1
    _ => 2
  }, 42)
}

2. 新增使用 T::{ ... }构造结构体的语法​

这个新语法可用于显式的指定结构体的类型，并会使得结构体内有更好的补全：

struct T {
  x: Int
  y: Int
}

struct T2 {
  x: Int
  y: Int
}

fn init {
  let x = T::{x: 1, y: 2}
  debug(x.x + x.y) // 3
}

3. 正式移除 var id = expr 的语法​

4. 增加了新的关键词 test​

新的测试语法 test "name" {}，用于代替原先的fn test_name(){}。目前暂时只有顶格缩进的test会被识别成关键字，未来将不再支持使用test作为标识符。 旧语法: fn test_ name {} 新语法: test " name " {}

5. 支持在 init 或者 test 代码块中使用 return 语句​

fn init  {
  if i > 0 {
    return
  }
  ...
}

test {
  if i > 0 {
    return
  }
  ...
}

插件更新​

改进了语法高亮：​

Before:

After:

mooncakes.io 更新​

1. 新增 mooncakes.io 注册方式​

现在mooncakes.io 支持使用用户名+邮箱方式注册，而不仅限于之前的GitHub登录方式。现在新用户可以抢先注册你心仪的用户名。（注意：用户名字符需要>=5，如果小于5需要联系管理员后台操作。）

$ moon register
Choose a way to register: Email
You chose: Email
Username: xxxxxx
Password: [hidden]
Email: xxxxxx@xxx.xx
Send verification code to your email[bzy_sustech@foxmail.com]? yes
Please input the verification code: xxxxxx
Register successfully!
API token saved in ~/.moon/credentials.json

2. 增加跳转到源代码的功能​

MoonBit更新​

1. 放宽了match的右手侧的语法，允许单个语句的出现。现在允许下面的写法：​

match x {
  A => return
  B => return 1
  C => i = i + 1
  D => break
  E => continue
  F => while true {}
}

2. 修复formatter的各种bug，例如：​

fn init {
  let mut a = 1
  {
    {
      let a = 2
      f(a)
    }
    let a = 3
    f(a)
    {
      let a = 4
      f(a)
    }
  }
  f(a)
}

fn init {
  let mut a = 1
  let a = 2
  f(a)
  let a = 3
  f(a)
  let a = 4
  f(a)
  f(a)
}

fn init {
  let mut a = 1
  {
    {
      let a = 2
      f(a)
    }
    let a = 3
    f(a)
    let a = 4
    f(a)
  }
  f(a)
}

3. 新增实验性inline测试机制​

声明格式为fn test_*，inline测试需要在普通的 *.mbt 文件中（而不是 *_test.mbt）声明，它既不能有参数也不能有返回类型，例如以下写法会报错：

现在 moon test 除了会执行每个包中以 _test.mbt 结尾的测试文件，还会执行每个包中的 inline 测试。

构建系统更新​

1. moon new给各个选项增加了默认值，用户可以使用回车选择默认值​

$ moon new
Enter the path to create the project (. for current directory) [default: myproject] >
Enter the create mode (exec or lib) [default: exec] >
Enter your username [default: username] >
Enter the package name [default: hello] >
Enter your license [default: Apache-2.0] >
Created my-project

2. moon.mod.json增加license和repository字段。​

license表示这个mooncakes.io所使用的licencse，必须符合spdx标准。

3. 正式移除moon check --daemon​

4. moon publish新增上传大小限制，上传大小必须小于16Mib​

其他更新​

1. windows平台的安装路径从~/.moon改为~/.moon/bin，与其他平台保持一致。​

2. 修复关于newtype goto definition 和 rename 的 bug​

MoonBit更新​

1. 正式移除 interface 关键字​

正式移除了 interface 关键字，使用 trait 代替。

2. 引入let mut id = expr​

根据社区的反馈，引入let mut id = expr的语法替代 var id = expr，下周将移除 var id = expr的支持。

3. 给 Array 类型增加了 Default 的实现​

例如：

fn init {
  debug(Array::default()) // []
}

4. 给 List 类型增加了 Default、Eq、和Debug 的实现​

例如：

fn init {
  let l1: List[_] = Cons(1, Cons(2, Cons(3, List::default())))
  let l2: List[_] = Cons(1, Cons(2, Cons(4, Nil)))
  debug(l1) // Cons(1, Cons(2, Cons(3, Nil)))
  debug(l1 == l2) // false
  debug(l2 == l2) // true
}

5. 修复对pub函数体的类型检查​

形如这样的例子：

priv type T
pub fn f() {
  let t: T = ... // public definition cannot depend on private type
      ...
}

之前会在T报错，但现在不会了。

插件更新​

1. 新增MoonBit AI​

目前已新增MoonBit AI，地址是https://ai.moonbitlang.com，欢迎大家试用。

2. 提高LSP稳定性​

修复一些会导致LSP崩溃的bug，提升LSP的稳定性。

构建系统更新​

1. 修复 moon test 会测试 .mooncakes 文件夹下的包的问题​

2. 废弃 moon check --daemon​

3. 改进 moon.pkg.json 格式或内容错误时的错误提示​

如下图所示：

MoonBit更新​

1. 上线了MoonBit包管理平台 mooncakes.io​

详细信息见：https://mp.weixin.qq.com/s/dBA4dA2fKL4FHc6KOcisBg

2. ⽀持了 recursive newtype​

可以在MoonBit中实现类型安全的y combinator:

type R[X] (R[X]) -> X

fn y[X, Y](f : ((X) -> Y) -> (X) -> Y) -> (X) -> Y {
  fn ff (x: R[(X) -> Y]) -> (X) -> Y {
    fn(a) { f(x.0(x))(a) }
  }
  ff(R::R(fn(x) { fn (a) { f(x.0(x))(a) } }))
}

fn factx(f: ((Int) -> Int)) -> (Int) -> Int {
  fn(n: Int) -> Int {
    if n <= 1 { 1 } else { n * f(n-1)}
  }
}

fn init {
  let fact = y(factx)
  let n = fact(10)
  println(n)
}

3. 新增内置函数sqrt​

用于计算二次方根

fn init {
  // sqrt 的类型是 Double -> Double
  println(sqrt(4.0)) // 2.0
}

4. 新增运算符 ===​

用于判断两个值是否引用相等：

fn init {
  let x = [1, 3]
  let y = [1, 3]
  let z = x
  if x === y {
    println("x === y")
  } else if x === z {
    println("x === z")
  }
  // Output: x === z
}

5. method/trait系统的更新：​

在过去的几周里，我们对 MoonBit 的方法/接口系统进行了许多设计上的调整，让它的行为更加合理、健壮。下面是现在的方法系统的行为：

• 方法是和类型关联的函数。可以通过下面的语法定义一个方法

fn T::method(...) -> ... { ... }

// 例如
type MyInt Int
fn MyInt::default() -> MyInt { MyInt(0) }

enum MyList[X] {
  Nil
  Cons(X, MyList[X])
}

fn MyList::map2[X, Y, R](
  f: (X, Y) -> R,
  xs: MyList[X],
  ys: MyList[Y]
) -> MyList[R] {
  ...
}

作为一种便捷的语法糖，当函数的第一个参数名为 self 时，Moonbit 会自动将它定义成 self的类型上的方法：

fn add(self: MyInt, other: MyInt) -> MyInt { ... }
// 等价于
fn MyInt::add(x: MyInt, y: MyInt) -> MyInt { ... }

• 方法都是普通函数。所以在没有歧义时，可以直接当成普通函数调用：

enum MyList[X] { ... }
fn MyList::length[X](xs: MyList[X]) -> Int {
  ...
}

fn init {
  let xs: MyList[_] = ...
  debug(length(xs))
}

如果有歧义无法直接调用，也可以用 T::method(...) 的形式显式调用：

struct Type1 { ... } derive(Debug)
fn Type1::default() -> Type1 { ... }

struct Type2 { ... } derive(Debug)
fn Type2::default() -> Type2 { ... }

fn init {
  // debug(default()): 有歧义！
  debug(Type1::default()) // ok
  debug(Type2::default()) // ok
}

• 当方法的第一个参数就是它所属的类型时，可以使用 x.method(...) 语法来快捷地调用。而且这种调用方式在跨包时不需要写出包名。MoonBit 会自动根据 x 的类型找到正确的方法：

// 名为 @list 的包
pub enum List[X] { ... }
pub fn map[X](self: List[X], f: (X) -> Y) -> List[Y] {
  ...
}

// 在另一个包中使用 @list
fn init {
  let xs: @list.List[_] = ...
  // 下面三种写法是等价的
  xs.map(...)
  @list.map(xs, ...) // 无歧义时可以如此调用
  @list.List::map(xs, ...)
}

• **只有类型所在的包可以给类型定义方法。**这保证了第三方包无法意外或恶意修改现有类型的行为和 trait 系统的一致性。

MoonBit 的 trait 系统的行为变化如下：

• trait 中的方法声明，任何时候都不再需要 Self:: 前缀。方法的第一个参数是否是 Self 对行为不再有影响

• 类型可以通过它现有的方法自动地实现一个 trait，不需要手动写出。但如果一个类型没有实现一个 trait，或者原本的实现不能满足需求，需要拓展它的功能，可以用如下的语法定义特殊的拓展方法，用于给一个类型显式地实现某个 trait：

// 给 [T] 实现 trait [Eq] 中的 [op_equal] 方法
fn Eq::op_equal(x: T, other: T) -> { ... }

这些拓展方法只能用于实现指定的 trait。例如，上面的拓展方法 Eq::op_equal 只能被用于实现 Eq，不能被用 T::op_equal 或是 t.op_equal(...) 的形式直接调用。在寻找 trait 的实现时，拓展方法的优先级比普通方法高。

• 只有类型所在的包或 trait 所在的包可以定义拓展方法。因此，某个类型为某个 trait 提供的实现在任何地方都是唯一且确定的。这保证了第三方包不会意外地更改一段程序的行为。

和之前相比，方法/trait 系统最大的不兼容改动是，现在不能给内建和第三方类型直接定义方法了。但通过心得拓展方法的机制，依然可以为内建/第三方类型实现新的 trait 来拓展功能。

构建系统更新​

1. moon.pkg.json 的 import 字段增加了数组的表示​

数组中要么是一个字符串，要么是一个 object { "path": ..., "alias": ...}，比如：

{
  "is_main": true,
  "import": [
    { "path": "moonbitlang/import004/lib", "alias": "lib" },
    "moonbitlang/import004/lib2", // 使用默认的alias: "lib2"
    { "path": "moonbitlang/import004/lib3", "alias": "lib3" },
    { "path": "moonbitlang/import004/lib4", "alias": "" } // 使用默认的alias: "lib4"
  ]
}

2. moon new现在支持通过交互式方式来创建项目。​

• 创建一个可执行项目

$ moon new
Enter the path to create the project (. for current directory) > myproject
Enter the create mode (exec or lib) > exec
Enter your username > moonbitlang
Enter the package name > hello

上面的命令等价于

 moon new --path myproject --user moonbitlang --name hello

这将会在文件夹 ./myproject 中创建一个名为 moonbitlang/hello 的项目，其目录结构为

.
├── lib
│   ├── hello.mbt
│   ├── hello_test.mbt
│   └── moon.pkg.json
├── main
│   ├── main.mbt
│   └── moon.pkg.json
└── moon.mod.json

• 创建一个包

$ moon new
Enter the path to create the project (. for current directory) > mylib
Enter the create mode (exec or lib) > lib
Enter your username > moonbitlang
Enter the package name > hello

上面的命令等价于

 moon new --path mylib --lib --user moonbitlang --name hello

这将会在文件夹 ./mylib 中创建一个名为 moonbitlang/hello 的包，其目录结构为

.
├── lib
│   ├── hello.mbt
│   ├── hello_test.mbt
│   └── moon.pkg.json
├── moon.mod.json
├── moon.pkg.json
└── top.mbt