trait A
trait B
def makeAWithB()(implicit constructor: Constructor[() => A with B]): A with B = {
constructor.newInstance()
}
val ab: A with B = makeAWithB()
Motivation
This feature is useful for library authors.
A library author may ask his user to create a trait type, then dynamically mix-in it with the features provided by the library.
Suppose you are creating a DSL that compiles to JavaScript.
You want your DSL is extensible.
For example, the DSL users should be able to create custom binary operators.
With the help of Constructor.scala, you can put the boilerplate code into a private class BinaryOperator:
The users of only need a very simple implementation for their custom binary operators.
import Ast._
trait Plus {
protectedfinaldef symbol = "+"
}
trait Minus {
protectedfinaldef symbol = "-"
}
val myAst = binaryOperator[Plus](
new Literal(1),
binaryOperator[Minus](
new Literal(3),
new Literal(5)
)
)
print(myAst.compile()) // Output: "(1 + (3 - 5))"
An alternative approach
There is another approach to integrate partial implementation from users: asking users to provide custom callback functions or type classes.
However, the callback functions or type classes approach will create additional object instances and additional references for each instance at run-time.
On the other hand, the Constructor.scala approach create classes at compile-time and no additional run-time references.
As a result, at run-time, Constructor.scala approach will consume less memory, and performs less indirect access on memory.
An implicit value for dynamically creating classes and traits, especially dynamic mixins.
Usage
Motivation
This feature is useful for library authors. A library author may ask his user to create a
trait
type, then dynamically mix-in it with the features provided by the library.Suppose you are creating a DSL that compiles to JavaScript.
You want your DSL is extensible. For example, the DSL users should be able to create custom binary operators.
With the help of
Constructor.scala
, you can put the boilerplate code into a private classBinaryOperator
:The users of only need a very simple implementation for their custom binary operators.
An alternative approach
There is another approach to integrate partial implementation from users: asking users to provide custom callback functions or type classes.
However, the callback functions or type classes approach will create additional object instances and additional references for each instance at run-time. On the other hand, the
Constructor.scala
approach create classes at compile-time and no additional run-time references. As a result, at run-time,Constructor.scala
approach will consume less memory, and performs less indirect access on memory.Author:
杨博 (Yang Bo) <[email protected]>