An export clause defines aliases for selected members of an object. Example:

class BitMap
class InkJet

class Printer:
  type PrinterType
  def print(bits: BitMap): Unit = ???
  def status: List[String] = ???

class Scanner:
  def scan(): BitMap = ???
  def status: List[String] = ???

class Copier:
  private val printUnit = new Printer { type PrinterType = InkJet }
  private val scanUnit = new Scanner

  export scanUnit.scan
  export printUnit.{status as _, *}

  def status: List[String] = printUnit.status ++ scanUnit.status

The two export clauses define the following export aliases in class Copier:

final def scan(): BitMap            = scanUnit.scan()
final def print(bits: BitMap): Unit = printUnit.print(bits)
final type PrinterType              = printUnit.PrinterType

With the experimental modularity language import, only exported methods and values are final, whereas the generated PrinterType would be a simple type alias

type PrinterType              = printUnit.PrinterType

These aliases can be accessed inside Copier as well as from outside:

val copier = new Copier
copier.print(copier.scan())

An export clause has the same format as an import clause. Its general form is:

export path . { sel_1, ..., sel_n }

It consists of a qualifier expression path, which must be a stable identifier, followed by one or more selectors sel_i that identify what gets an alias. Selectors can be of one of the following forms:

• A simple selector x creates aliases for all eligible members of path that are named x.
• A renaming selector x as y creates aliases for all eligible members of path that are named x, but the alias is named y instead of x.
• An omitting selector x as _ prevents x from being aliased by a subsequent wildcard selector.
• A given selector given x has an optional type bound x. It creates aliases for all eligible given instances that conform to either x, or Any if x is omitted, except for members that are named by a previous simple, renaming, or omitting selector.
• A wildcard selector * creates aliases for all eligible members of path except for given instances, synthetic members generated by the compiler and those members that are named by a previous simple, renaming, or omitting selector.
  Notes:
  • eligible construtor proxies are also included, even though they are synthetic members.
  • members created by an export are also included. They are created by the compiler, but are not considered synthetic.

A member is eligible if all of the following holds:

• its owner is not a base class of the class(*) containing the export clause,
• the member does not override a concrete definition that has as owner a base class of the class containing the export clause.
• it is accessible at the export clause,
• it is not a constructor, nor the (synthetic) class part of an object,
• it is a given instance (declared with given) if and only if the export is from a given selector.

It is a compile-time error if a simple or renaming selector does not identify any eligible members.

Type members are aliased by type definitions, and term members are aliased by method definitions. For instance:

object O:
  class C(val x: Int)
  def m(c: C): Int = c.x + 1
export O.*
  // generates
  //   type C = O.C
  //   def m(c: O.C): Int = O.m(c)

Export aliases copy the type and value parameters of the members they refer to. Export aliases of term members are always final. Aliases of given instances are again defined as givens (and aliases of old-style implicits are implicit). Aliases of extensions are again defined as extensions. Aliases of inline methods or values are again defined inline. There are no other modifiers that can be given to an alias. This has the following consequences for overriding:

• Export aliases of methods or fields cannot be overridden, since they are final.
• Export aliases cannot override concrete members in base classes, since they are not marked override.
• However, export aliases can implement deferred members of base classes.
• Export type aliases are normally also final, except when the experimental language import modularity is present. The general rules for type aliases ensure in any case that if there are several type aliases in a class, they must agree on their right hand sides, or the class could not be instantiated. So dropping the final for export type aliases is safe.

Export aliases for public value definitions that are accessed without referring to private values in the qualifier path are marked by the compiler as "stable" and their result types are the singleton types of the aliased definitions. This means that they can be used as parts of stable identifier paths, even though they are technically methods. For instance, the following is OK:

class C { type T }
object O { val c: C = ... }
export O.c
def f: c.T = ...

Restrictions:

1. Export clauses can appear in classes or they can appear at the top-level. An export clause cannot appear as a statement in a block.

2. If an export clause contains a wildcard or given selector, it is forbidden for its qualifier path to refer to a package. This is because it is not yet known how to safely track wildcard dependencies to a package for the purposes of incremental compilation.

3. An export renaming hides un-renamed exports matching the target name. For instance, the following clause would be invalid since B is hidden by the renaming A as B.

   export {A as B, B}        // error: B is hidden
   

4. Renamings in an export clause must have pairwise different target names. For instance, the following clause would be invalid:

   export {A as C, B as C}   // error: duplicate renaming
   

5. Simple renaming exports like

   export status as stat
   

   are not supported yet. They would run afoul of the restriction that the exported a cannot be already a member of the object containing the export. This restriction might be lifted in the future.

(*) Note: Unless otherwise stated, the term "class" in this discussion also includes object and trait definitions.

class StringOps(x: String):
  def *(n: Int): String = ...
  def capitalize: String = ...

extension (x: String)
  def take(n: Int): String = x.substring(0, n)
  def drop(n: Int): String = x.substring(n)
  private def moreOps = new StringOps(x)
  export moreOps.*

extension (x: String)
  def take(n: Int): String = x.substring(0, n)
  def drop(n: Int): String = x.substring(n)
  private def moreOps = StringOps(x)
  def *(n: Int): String = moreOps.*(n)
  def capitalize: String = moreOps.capitalize

TemplateStat      ::=  ...
                    |  Export
TopStat           ::=  ...
                    |  Export
ExtMethod         ::=  ...
                    |  Export
Export            ::=  ‘export’ ImportExpr {‘,’ ImportExpr}
ImportExpr        ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
ImportSpec        ::=  NamedSelector
                    |  WildcardSelector
                    | ‘{’ ImportSelectors) ‘}’
NamedSelector     ::=  id [‘as’ (id | ‘_’)]
WildCardSelector  ::=  ‘*’ | ‘given’ [InfixType]
ImportSelectors   ::=  NamedSelector [‘,’ ImportSelectors]
                    |  WildCardSelector {‘,’ WildCardSelector}

class B { val c: Int }
object A { val b = new B }
export A.*
export b.*

export b.*
export A.*