मैक्रोज़ - स्कैला, प्रकार, मैक्रोज़ का उपयोग करके बिल्डर और मूल्य में कॉन्फ़िगरेशन स्टब का विस्तार करना

एक अधिक काल्पनिक सवाल। क्या यह मुमकिन, स्काला मैक्रोज़ का उपयोग करते हुए, इस तरह की संरचना को चालू करने के लिए:

object Foo extends Factory {  // Factory = expansion magic
trait Config {
val i: Int = 33
val s: String = "foo"
}

def apply(c: Config): Foo = ???
}
trait Foo

(अधिक या कम स्वचालित रूप से) इसमें:

object Foo {
sealed trait ConfigLike {
def i: Int
def s: String
}
object Config {
def apply() = new ConfigBuilder
implicit def build(b: ConfigBuilder) = b.build
}
final case class Config(i: Int, s: String) extends ConfigLike
object ConfigBuilder {
def apply(c: Config) = {
val b = new ConfigBuilder
b.read(c)
b
}
}
final class ConfigBuilder extends ConfigLike {
var i: Int = 33
var s: String = "foo"
def build: Config = Config(i, s)
def read(c: Config) {
i = c.i
s = c.s
}
}

def apply(c: Config = Config()): Foo = ???
}

उदाहरण:

val c = Foo.Config()
c.i = 44
c.s = "bar"
val f = Foo(c)

क्या यह स्वर्ग टाइप-मैक्रोज़ है?

यदि हां, तो कोई भी टाइप-मैक्रोज़ के विकास को क्यों रोकना चाहेगा?

उत्तर:

हाँ, वह किस प्रकार के मैक्रोज़ करने के लिए डिज़ाइन किया गया था। उन्हें छोड़ दिया गया था, क्योंकि वे अन्य चीजें भी कर सकते हैं जिन्हें हम उजागर करने के बारे में निश्चित नहीं हैं। फिर भी, हम कोडेनरेशन के मूल्य को पहचानते हैं, और फिलहाल हम इसे प्राप्त करने के लिए अन्य रास्ते तलाश रहे हैं (जैसे कि मैक्रो एनोटेशन)।