Question

我想知道是否有人有创建类型参数化类型层次结构的经验？我相当肯定，由于scala的伪统一包和＆amp ;;这是可行的。静态对象。

我想到的具体用例是在应用程序框架上对id类型进行参数化，以便您可以选择int / long / java.util.UUID / BSONId /随你。考虑一个粗略的例子：

package foolib.generic

trait GenEntity[I] { def id: I }

trait GenRepository[I] { def getById(id: I): GenEntity[I] }

trait FooTaxonomy[I] {
  type Entity = GenEntity[I]
  type Repository = GenRepository[I]

  object subpackage extends generic.subpackage.SubpackageTaxonomy[I]
}

然后，您将在项目中使用以下内容配置层次结构：

package object myprj {
  object foolib extends foolib.generic.FooTaxonomy[java.util.UUID]

  // Whee!
  val someEntity = new myprj.foolib.Entity(java.util.UUID.randomUUID())
}

有什么理由这是一个非常糟糕的主意吗？我应该注意哪些陷阱/等等？

Answer 1

此方法可行，但在类型参数数量增加时可能会遇到问题。也许解决方案是使用抽象类型成员而不是类型参数。

另一种方法是使用蛋糕模式，我认为在您的情况下提供更好的解决方案。你的代码的确切逻辑使我有点不知所措，所以这次重写可能并不完全代表你的意图：

package foolib.generic


//defines common types used by all modules
trait CoreModule {

    type Id // abstract type, not commited to any particular implementation

}

//module defining the EntityModule trait
trait EntityModule { this: CoreModule => //specifying core module as a dependency

    trait GenEntity {
        def id: Id
    }

    def mkEntity(id: Id): Entity //abstract way of creating an entity

}

//defines the GenRepository trait
trait RepositoryModule { this: EntityModule with CoreModule => //multiple dependencies

    trait GenRepository {
        def getById(id: Id): GenEntity
    }

    val repository: GenRepository //abstract way of obtaining a repository

}

//concrete implementation for entity
trait EntityImplModule extends EntityModule { this: CoreModule =>
    case class Entity(val id: Id) extends GenEntity

    def mkEntity(id: Id) = Entity(id)
}

//modules that provides a concrete implementation for GenRepository
trait RepositoryImplModule extends RepositoryModule { this: CoreModule with EntityModule =>

    object RepositoryImpl extends GenRepository {
        def getById(id: Id) = mkEntity(id)
    }

}

//this unifies all your modules. You can also bind any dependencies and specify any types
object Universe
    extends CoreModule
    with EntityImplModule
    with RepositoryImplModule {

    type Id = java.util.UUID

    val repository = RepositoryImpl

    def mkEntity(id: Id) = Entity(id)

}

//usage
object Main {

    import Universe._
    import java.util.UUID

    val entity = repository.getById(UUID.randomUUID())
    println(entity.id)

}

这实现了创建独立于具体类型Id的实现的目标，并且它还提供了一种执行依赖注入的好方法。

例如，为GenRepository提供具体实现的模块可能需要Id的具体类型。您可以很好地创建另一个模块，将Id绑定到具体类型，并使RepositoryImplModule依赖于前一个模块，从而指定GenRepository的这个具体实现仅适用于某个模块ids的类型。

蛋糕模式非常强大，有很多变化。这段视频解释得非常好，如果您对此解决方案感兴趣，我建议您观看：

Cake Pattern: The Bakery from the Black Lagoon

类型参数化类型层次结构

1 个答案: