标签: cake-pattern

我必须在一个使用蛋糕模式的项目中集成一些宏.这种模式使我们能够避免数以万计的进口,以及其他优势,因此我们希望保留它.现在,我们正面临一些问题,我们已经在主干外测试了一些实验宏.首先,让我们展示一个名为Cake的虚拟系统:

trait APiece {
  class A
}

trait BPiece { this: APiece => 
  def aMacro(a: A): Unit = () /* macro ??? */
}

trait CPiece { this: APiece with BPiece =>
  def aMacroInvoker = aMacro(new A)
}

class Cake { this: APiece with BPiece with CPiece => }

APiece定义了一个类,BPiece应该是一个使用APiece定义类的宏,最后,CPiece调用宏.我说BPiece应该是一个宏,因为我无法为它编写实现代码.我尝试了几种方法,但我总是崩溃以下错误:

"macro implementation must be in statically accessible object"

读取宏代码可以猜测将宏封装在静态模块中是必要的.有没有办法部署使用系统结构的宏？

我想了解蛋糕模式.

我正在阅读这篇关于它的博客.

该博客的示例代码是:

case class User (name:String,email:String,supervisorId:Int,firstName:String,lastName:String)

trait UserRepository {
  def get(id: Int): User
  def find(username: String): User
}
trait UserRepositoryComponent {

  def userRepository: UserRepository

  trait UserRepository {
    def get(id: Int): User
    def find(username: String): User
  }
}
trait Users {
  this: UserRepositoryComponent =>

  def getUser(id: Int): User = {
    userRepository.get(id)
  }

  def findUser(username: String): User = {
    userRepository.find(username)
  }
}
trait UserInfo extends Users {
  this: UserRepositoryComponent =>

  def userEmail(id: Int): String = {
    getUser(id).email
  }

  def …

我正在努力在我的应用程序上使用蛋糕模式.

在网上找到的例子中,例子是基本的,但不涉及更复杂的需求.我想做的事情并不那么花哨:我想在蛋糕模式应用程序中使用相同类型的2个服务,使用不同的实现.

trait UserServiceComponent {
  self: UserRepositoryComponent =>
  val userService: UserService

  class DefaultUserService extends UserService {
    def getPublicProfile(id: String): Either[Error, User] = userRepository.getPublicProfile(id)
  }

  class AlternativeUserService extends UserService {
    def getPublicProfile(id: String): Either[Error, User] = call webservice here for exemple...
  }
}

trait UserService extends RepositoryDelegator[User] {
  def getPublicProfile(id: String): Either[Error, User]
}

如果我一次使用一个实现,它工作正常UserService,但如果我在同一时间需要两个实现,我真的不知道如何做到这一点.

我应该创建2个不同的组件吗？每一个都暴露出不同的userService值名称？(defaultUserService/alternativeUserService).使用一个组件进行实现我不知道其他组件在使用名称时如何能够知道使用哪个实现,userService因为我的应用程序中有2个不同的实现.

顺便说一下,当组件表达UserRepositoryComponent对它的依赖关系时,虽然并非所有实现都需要它,但我发现只有一个组件正确有点奇怪吗？想象一下,我不想构建需要两种实现的完整应用程序,但是我需要为了测试只构建不需要的AlternativeUserService,UserRepositoryComponent因为它不会提供这种依赖关系会很奇怪.用过的.

有人可以给我一些建议,以便我知道该怎么做？

一种相关问题: Cake模式:如何获取组件提供的UserService类型的所有对象

谢谢

关于这个问题,我现在有以下内容:

case class Pet(val name: String)

trait ConfigComponent {
  type Config

  def config: Config
}

trait VetModule extends ConfigComponent {
  type Config <: VetModuleConfig

  def vet: Vet

  trait Vet {
    def vaccinate(pet: Pet)
  }

  trait VetModuleConfig {
    def extra: String
  }

}

trait VetModuleImpl extends VetModule {
  override def vet: Vet = VetImpl

  object VetImpl extends Vet {
    def vaccinate(pet: Pet) = println("Vaccinate:" + pet + " " + config.extra)
  }

}

trait AnotherModule extends ConfigComponent {
  type …

我试图想出一个合成场景,其中自我类型和扩展行为不同,到目前为止还没有找到一个.基本示例总是讨论一种自我类型,不要求类/特征不必是依赖类型的子类型,但即使在那种情况下,自我类型和扩展之间的行为似乎是相同的.

trait Fooable { def X: String }
trait Bar1 { self: Fooable =>
  def Y = X + "-bar"
}
trait Bar2 extends Fooable {
  def Y = X + "-bar"
}
trait Foo extends Fooable {
  def X = "foo"
}
val b1 = new Bar1 with Foo
val b2 = new Bar2 with Foo

是否存在某种形式的组合对象的某种形式的组合或功能在使用一种与另一种时不同的情况？

更新1:感谢没有自我键入的事情的例子,我很欣赏这些信息,但我真的在寻找自我和扩展可能的组合,但不可互换.

更新2:我想我遇到的具体问题是为什么各种Cake Pattern示例通常都会讨论必须使用self-type而不是extends.我还没有找到一个与扩展无关的Cake Pattern场景

这个问题可以帮助您了解我的需求. 蛋糕模式:每个实现一个组件,或每个特性一个组件？

我有一个使用多个UserService实现的Scala应用程序,它将由组件(s？)提供.

我想知道在另一个组件中是否有一种方法可以"扫描"应用程序,以便我可以检索一组提供实现特征UserService的对象的所有组件？这样我可以迭代我的蛋糕构建应用程序提供的所有UserService接口？

我想我可以有一个组件根据其依赖关系构建一个UserService列表,但是有没有可能让这个组件构建列表而没有任何硬编码依赖？

蛋糕图案的一个很大的局限是它的静电.我希望能够完全独立地混合使用由不同编码器编写的特征.然而性状会不会需要混合式频繁.在运行主应用程序之前,用户将有一个初始化屏幕,用于选择特征/组件.所以我想到了为什么不在用户选择选择模块中混合和编译所选择的特征.如果编译失败,用户只会收到一些消息 - 不兼容的程序集或者什么都没有问题.如果编译成功,那么顶级UI模块将使用程序集的预编译部分加载新编译的类并运行主应用程序.注意,在运行时初始化期间可能只需要编译一个或两个类.所有其余的代码都可以正常编译.

我对Scala很新.这是一种公认​​的模式吗？有没有支持呢？在相对简单的依赖情况下使用Guice似乎很疯狂.我可以在应用程序中轻松运行Scala编译器吗？我可以在内存中运行它,它的输出可以从内存中使用而不需要创建不必要的文件吗

注意:虽然看似动态,但这种方法仍然是100%静态的.

编辑它发生在微软的Roslyn项目的一个驱动器是为C#和Visual Basic启用这种事情.但即使对于高性能的微软团队来说,这似乎也是一个相当大的项目.

我试图将我对蛋糕模式的理解转换为简单的scala代码,并发现它没有编译.有人可以看看下面的代码,并告诉我这是什么方式我理解模式的问题？我读了这篇文章并尝试了类似的东西(http://www.cakesolutions.net/teamblogs/2011/12/19/cake-pattern-in-depth)

在下面的代码中 - println("This is " + userServiceComponent.whatCalc1) //> This is ()我期待它打印This is ScifiCalc Calc但是它的打印This is ()

码:-

trait Calc {
  def whatCalc
}

trait NormalCalc extends Calc {
  def whatCalc = new String("Normal Calc")
}

trait ScifiCalc extends Calc {
  def whatCalc = new String("ScifiCalc Calc")
}

trait TestTrait{
  def whatCalc1
}

trait TestCalc extends TestTrait {  
  this: Calc =>;

  def whatCalc1 = {
    whatCalc
  }
}

object SelfReferenceExample {
  println("Welcome to the …

我正在尝试实现类似代码的蛋糕模式，但我得到：

Error:(47, 36) illegal inheritance;
 self-type app.server.im.Im_Api_Service_Impl.type does not conform to app.server.im.Persistence[app.server.im.State.State]'s selftype app.server.im.Persistence[app.server.im.State.State] with app.server.im.Persistable[app.server.im.State.State]
object Im_Api_Service_Impl extends Persistence[State.State]

使用下面的代码。

可能是什么问题？

我看着这个SOF question，但它似乎描述了一个不同的场景（或者我可能只是没有看到相似之处）。

import app.shared.IndexChange
import app.shared.apiAndModel.im.{CanCreateEntity, Im_Api_Interface, LineShared, LineSharedPayload, UUID}
import upickle.default._
object State {
  type State = Seq[LineShared]
}

trait  Im_Api_Service extends Im_Api_Interface with Persistable[State.State] {
  implicit object CanCreate extends CanCreateEntity
  import State.State
  val init = List("egy", "ketto", "harom", "negy", "ot", "hat", "het", "nyolc").map(LineSharedPayload(_)).map(LineShared(_))

  val fileNameForPersistence="state"

  var state: State = init

  def setState(s:State)={state=s}

  override def …