Question

在我的Scala项目中，几乎所有文件都有这些导入：

import eu.timepit.refined._
import eu.timepit.refined.api.Refined
import eu.timepit.refined.auto._
import eu.timepit.refined.numeric._

import spire.math._
import spire.implicits._

import com.wix.accord._
import com.wix.accord.dsl._

import codes.reactive.scalatime._

import better.files._

import java.time._

import scala.collection.mutable
...
...

在Scala中干燥这个的最佳方法是什么？我可以为我的项目（使用某种sbt插件吗？）或在包级别指定所有这些？

Answer 1

我已经看到了一些解决你正在寻找的方法。看看

导入已定义

https://github.com/mongodb/casbah/blob/master/casbah-core/src/main/scala/Implicits.scala

这种方法的一个小例子：

object Imports extends Imports with commons.Imports with query.Imports with query.dsl.FluidQueryBarewordOps

object BaseImports extends BaseImports with commons.BaseImports with query.BaseImports

object TypeImports extends TypeImports with commons.TypeImports with query.TypeImports

trait Imports extends BaseImports with TypeImports with Implicits

@SuppressWarnings(Array("deprecation"))
trait BaseImports {
  // ...
  val WriteConcern = com.mongodb.casbah.WriteConcern
  // More here ...
}

trait TypeImports {
  // ...
  type WriteConcern = com.mongodb.WriteConcern
  // ... 
}

使用的进口

https://github.com/mongodb/casbah/blob/master/casbah-core/src/main/scala/MongoClient.scala

当他们使用此导入对象时，它会为您解锁所有类型别名。例如，WriteConcern

import com.mongodb.casbah.Imports._
// ...
def setWriteConcern(concern: WriteConcern): Unit = underlying.setWriteConcern(concern)

基本上它们将所有导入包装到一个公共的Import对象中，然后只使用import com.mycompany.Imports ._

Doobie在大多数最终用户只有import doobie.imports._

的情况下做了类似的事情

https://github.com/tpolecat/doobie/blob/series/0.3.x/yax/core/src/main/scala/doobie/imports.scala

再次，来自这种模式的样本：

object imports extends ToDoobieCatchSqlOps with ToDoobieCatchableOps {
  /**
   * Alias for `doobie.free.connection`.
   * @group Free Module Aliases
   */
  val FC   = doobie.free.connection

  /**
   * Alias for `doobie.free.statement`.
   * @group Free Module Aliases
   */
  val FS   = doobie.free.statement

  // More here ...
}

这种方法在包对象样式之间的主要区别在于您可以更好地控制导入的内容/时间。我已经使用了两种模式，通常是一个包对象，用于内部包中需要的常用实用方法。对于库，特别是我的代码的用户，我可以将某些隐式定义附加到上面提到的doobie中的导入对象，这将使用单个导入为用户解锁DSL语法。

Answer 2

我可能会使用scala.Predef approach：基本上，为类型添加别名并公开我想要提供的对象。例如，

package com.my

package object project {
  type LocalDate = java.time.LocalDate
  type LocalDateTime = java.time.LocalDateTime
  type LocalTime = java.time.LocalTime

  import scala.collection.mutable

  type MutMap[A, B] = mutable.Map[A, B]
  val MutMap = mutable.Map
  // And so on....
}

现在，无论您使用package com.my.project启动文件，以上所有内容都将自动可用。顺便说一句，也感谢@ {som-snytt pointing this out。

在Scala中捆绑导入

2 个答案: