项目

实现前

实现后

代码组织方式

模块/包 二级结构

包/子包 树形结构

没有父包的包称为 root 包，root 包及其子包（包括子包的子包）构成的整棵树称为 module

编译单元

包

包（每个子包单独编译）

访问修饰符

public：

可修饰顶层和非顶层成员，包内外可见

default（不写）：仅本包内可见

protected：只能修饰 class 的成员，本包内可见、本 class 及其子类可见

private：不能修饰 top-level 成员、仅当前作用域可见

以下所有访问修饰符均可修饰顶层和非顶层成员

public：本 module 内外可见

protected：本 module 和子类型内可见

internal：本包及其子树可见

private：修饰顶层声明时仅本文件内可见，修饰非顶层声明时仅当前类型或扩展定义内可见

package 访问修饰符

无

package a.b（= public package a.b）

protected package a.b

internal package a.b

import 访问修饰符

public import

import

public import

protected import

internal import

import（= private import）

从 module 导入的语法

from std import time.*

不再有 from 语法，只有 import std.time.* 的语法

多导入的语法

from std import time.*, math.*

import a.*, b.*

import std.{time.*, math.*}

import {a.*, b.*}

导入的语义

from std import time.Duration

可以同时看到 time 和 Duration 这两个符号

import std.time.Duration

只看能看到 Duration 这一个符号

单导入

可以导入顶层声明，不可以导入包名

from std import time // error

from std import time.Duration // OK

可以导入顶层声明、也可以导入包名

import std.time // ok

import std.time.Duration // OK

别名导入

from std import time.* as stdTime.* // OK

from std import time.Duration as stdDuration // OK

import std.time.* as stdTime.* // error

import std.time.Duration as stdDuration // OK

别名导入的作用域

和当前包顶层声明处于同一作用域

from std import time.Duration as stdDuration

let stdDuration = 1 // error: redefinition

和当前包顶层声明处于不同作用域，且优先级更低，若 shadow 则告警

import std.time.Duration as stdDuration // warning: shadow

let stdDuration = 1 // OK

重复导入并取别名

使用 import as 对导入的声明重命名后，当前包内只能使用别名，无法使用原名

from std import time.Duration // error: time.Duration is renamed

from std import time.Duration as stdDuration

允许使用多条导入语句分别导入原名和重命名

import std.time.Duration

import std.time.Duration as Duration1

import std.time.Duration as Duration2


let _ = Duration.second // OK

let _ = Duration1.second // OK

let _ = Duration2.second // OK

package hello
import std.random.*//from xxx import bbb -> import xxx.bbb
import std.math.*

main(): Int64 {
    const N = 1000000
    var n: UInt32 = 0
    let random = Random()
    for (_ in 0..N) {
        let x = random.nextFloat64()
        let y = random.nextFloat64()
        if ((x - 0.5) ** 2 + (y - 0.5) ** 2 < 0.25) {
            n += 1
        }
    }
    let pi = Float64(n) / Float64(N) * 4.0
    println('pi = ${pi}')
    println('deviation = ${abs(Float64.PI - pi)}')
    println("hello world")
    return 0
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.