CangjieDocsHub

Section Text

扩展也是可以被导入和导出的，但是扩展本身不能使用可见性修饰符修饰，扩展的导出有一套特殊的规则。
 
对于直接扩展，当扩展与被扩展的类型在同一个包中，扩展是否导出，由被扩展类型与泛型约束（如果有）的访问修饰符同时决定，当所有的泛型约束都是导出类型（修饰符与导出规则，详见[顶层声明的可见性](../package/toplevel_access.md)章节）时，该扩展将被导出。当扩展与被扩展类型不在同一个包中时，该扩展不会导出。
 
如以下代码所示，`Foo` 是导出的，`f1` 函数所在的扩展由于不导出泛型约束，故该扩展不会被导出；`f2` 和 `f3` 函数所在的扩展的泛型约束均被导出，故该扩展被导出；`f4` 函数所在的扩展包含多个泛型约束，且泛型约束中 `I1` 未被导出，故该扩展不会被导出；`f5` 函数所在的扩展包含多个泛型约束，所有的泛型约束均是导出的，故该扩展会被导出。
 
对于接口扩展则分为两种情况：
 
1. 当接口扩展与被扩展类型在相同的 `package` 时，扩展会与被扩展类型以及泛型约束（如果有）一起被导出，不受接口类型的访问级别影响，包外不需要导入接口类型也能访问该扩展的成员。
2. 当接口扩展与被扩展类型在不同的 `package` 时，接口扩展是否导出由接口类型以及泛型约束（如果有）里用到的类型中最小的访问级别决定。其他 `package` 必须导入被扩展类型、相应的接口以及约束用到的类型（如果有），才能访问对应接口包含的扩展成员。
 
如下代码所示，在包 `a` 中，虽然接口访问修饰符为 `private`，但 `Foo` 的扩展仍然会被导出。
 
当在其他包中为 `Foo` 类型扩展时，扩展是否导出由实现接口和泛型约束的访问修饰符决定。实现接口至少存在一个导出的接口，且所有的泛型约束均可导出时，该扩展将被导出。
 
特别的，接口扩展导出的成员仅限于接口中包含的成员。
 
<!-- compile.error -access_rules3 -->
<!-- cfg="-p a --output-type=staticlib" -->
 
<!-- compile.error -access_rules3 -->
<!-- cfg="-p b --output-type=staticlib" -->
 
<!-- compile.error -access_rules3 -->
<!-- cfg="-p c --output-type=staticlib" -->
<!-- cfg="liba.a libb.a" -->
 
与扩展的导出类似，扩展的导入也不需要显式地用 `import` 导入，扩展的导入只需要导入被扩展的类型、接口和泛型约束，就可以导入可访问的所有扩展。
 
如下面的代码所示，在 `package b` 中，只需要导入 `Foo` 就可以使用 `Foo` 对应的扩展中的函数 `f`。
 
而对于接口扩展，需要同时导入被扩展的类型、扩展的接口和泛型约束（如果有）才能使用。因此在 `package c` 中，需要同时导入 `Foo` 和 `I` 才能使用对应扩展中的函数 `g`。
 
<!-- compile -->

Code 1 · cangjie

// package a.b
package a.b
 
private interface I1 {}
internal interface I2 {}
protected interface I3 {}
 
extend Int64 <: I1 & I2 & I3 {}
 
public class Foo<T> {}
// The extension will not be exported
extend<T> Foo<T> where T <: I1 {
    public func f1() {}
}
// The extension will be exported, and only packages that import both Foo and I2 will be able to access it.
extend<T> Foo<T> where T <: I2 {
    public func f2() {}
}
// The extension will be exported, and only packages that import both Foo and I3 will be able to access it.
extend<T> Foo<T> where T <: I3 {
    public func f3() {}
}
// The extension will not be exported. The I1 with the lowest access level determines the export.
extend<T> Foo<T> where T <: I1 & I2 & I3 {
    public func f4() {}
}
// The extension is exported. Only the package that imports Foo, I2, and I3 can access the extension.
extend<T> Foo<T> where T <: I2 & I3 {
    public func f5() {}
}
 
// package a.c
package a.c
import a.b.*
 
main() {
    Foo<Int64>().f1() // Cannot access.
    Foo<Int64>().f2() // Cannot access. Visible only for sub-pkg.
    Foo<Int64>().f3() // OK.
    Foo<Int64>().f4() // Cannot access.
    Foo<Int64>().f5() // Cannot access. Visible only for sub-pkg.
}
 
// package a.b.d
package a.b.d
import a.b.*
 
main() {
    Foo<Int64>().f1() // Cannot access.
    Foo<Int64>().f2() // OK.
    Foo<Int64>().f3() // OK.
    Foo<Int64>().f4() // Cannot access.
    Foo<Int64>().f5() // OK.
}

Code 2 · cangjie

// package a
package a
 
private interface I0 {}
 
public class Foo<T> {}
 
// The extension is exported.
extend<T> Foo<T> <: I0 {}

Code 3 · cangjie

// package b
package b
 
import a.Foo
 
private interface I1 {}
internal interface I2 {}
protected interface I3 {}
public interface I4 {}
 
// The extension will not be exported because I1 is not visible outside the file.
extend<T> Foo<T> <: I1 {}
 
// The extension is exported.
extend<T> Foo<T> <: I2 {}
 
// The extension is exported.
extend<T> Foo<T> <: I3 {}
 
// The extension is exported
extend<T> Foo<T> <: I1 & I2 & I3 {}
 
// The extension will not be exported. The I1 with the lowest access level determines the export.
extend<T> Foo<T> <: I4 where T <: I1 & I2 & I3 {}
 
// The extension is exported.
extend<T> Foo<T> <: I4 where T <: I2 & I3 {}
 
// The extension is exported.
extend<T> Foo<T> <: I4 & I3 where T <: I2 {}

Code 4 · cangjie

// package a
package a
 
public class Foo {}

Code 5 · cangjie

// package b
package b
 
import a.Foo
 
public interface I1 {
    func f1(): Unit
}
 
public interface I2 {
    func f2(): Unit
}
 
extend Foo <: I1 & I2 {
    public func f1(): Unit {}
    public func f2(): Unit {}
    public func f3(): Unit {} // f3 will not be exported
}

Code 6 · cangjie

// package c
package c
 
import a.Foo
import b.I1
 
main() {
    let x: Foo = Foo()
    x.f1() // OK, because f1 is a member of I1.
    x.f2() // error, I2 is not imported
    x.f3() // error, f3 not found
}

Code 7 · cangjie

// package a
package a
public class Foo {}
extend Foo {
    public func f() {}
}

Code 8 · cangjie

// package b
package b
import a.Foo
 
public interface I {
    func g(): Unit
}
extend Foo <: I {
    public func g() {
        this.f() // OK
    }
}

Code 9 · cangjie

// package c
package c
import a.Foo
import b.I
 
func test() {
    let a = Foo()
    a.f() // OK
    a.g() // OK
}

Access Rules

English

中文