如何进行嵌套导入

Question

我正在尝试清理我的用户 api，以便用户可以整齐地从单个包对象导入，并获取所有内容。我意识到我可以将我的包裹移动到顶部包裹中，但我想知道是否有办法执行以下操作（我知道这可能不是最佳实践）：

我有以下软件包：

package org.Me.packages.packageA

case class A() {
// some implementation
}

package org.Me.packages.packageB

case class B() {
// some implementation
}

现在这将需要导入表单：

import org.Me.packages.packageA.A
import org.Me.packages.packageB.B

我被要求做的是以下内容：

package org.Me.combinedPackages

package object Combined {
   import org.Me.packages.packageA.A
   import org.Me.packages.packageB.B 
}

这样我的最终用户就可以简单地执行以下操作：

import org.Me.combinedPackages._

// access both a and b here

从我在这里读到的，我理解这意味着嵌套导入是不可能的。

那么我想要做的事情是不可能的吗？我意识到存在其他方式。

Answer 1

在 Dotty 中，您可以通过export（双到import）执行以下操作：

package org.Me.combinedPackages


export org.Me.packages.packageA.A
export org.Me.packages.packageB.B 

但是，在 Scala 2 中，您必须：

• 为您想要“传递”的每种类型使用类型别名，以便从您的包中访问
• val为您希望通过包重定向的每个（伴随）对象使用 a

package my.package

// imported as my.package.exported._
package object exported {

  type NormalType = some.other.package.NormalType
  val NormalType: some.other.package.NormalType.type =
    some.other.package.NormalType
  
  type ParametricType[F[_], A] = some.other.package.ParametricType[F, A]
  val ParametricType: some.other.package.ParametricType.type =
    some.other.package.ParametricType

  // be careful to not import things that are automatically imported
  // e.g. implicits in companions, and avoid importing the same implicit
  // twice from two different packages
  implicit val redirectedImplicit: some.other.package.SomeImplicit =
    some.other.package.SomeImplicit
}

以防万一，我只是提到这会中断例如宏注释，就好像您在宏注释类型中有这样的别名一样，编译器不会认识到它应该使用原始类型的宏扩展来处理它。