如何在另一个构造函数中获取类似 Map 的糖

Question

我需要是一个类XI，它可以用一个将字符串放入其他字符串的映射或将字符串放入字符串的映射，然后构造任意数量的其他X实例。由于我对Scala，我知道我可以做到这一点：

class Person (stringParms : Map[String, String],
        mapParms : Map[String, Map[String, String]],
        children : List[X]) {
}

但这看起来不太像 Scala（“Scalish”？“Scalerific”？“Scaological”？）我希望能够做到以下几点：

Person bob = Person("name" -> "Bob", "pets" -> ("cat" -> "Mittens", "dog" -> "Spot"), "status" -> "asleep", 
        firstChild, secondChild)

我知道我可以通过使用伴生对象摆脱“新”，我确信我可以查看 Scala 可变参数。我想知道的是：

1. 我如何使用 -> （或一些类似合理的运算符）来构造要在构造中制作成 Map 的元素？
2. 我如何定义一个映射，以便它可以在两种完全不同的类型之间进行类似选项的切换，或者成为递归树，其中每个（命名）节点指向字符串形式的叶子或像它自己一样的另一个节点？

递归版本确实很吸引我，因为虽然它没有解决我今天实际遇到的问题，但它巧妙地映射到仅包含对象和字符串（没有数字或数组）的 JSON 子集。

一如既往，非常感谢任何帮助。

Answer 1

-> 只是一个语法糖来组成一对 (A, B)，因此您也可以使用它。 Map 对象接受成对的 vararg：

def apply [A, B] (elems: (A, B)*) : Map[A, B]

您应该首先查看 架构Scala Collections（如果您有兴趣模仿集合库）。

话虽如此，我不认为您为 Person 提出的签名看起来像 Map，因为它需要变量参数，但 children 却不是与其他 (String, A) 主题连续。如果你说“child1”-> Alice，并在内部单独存储Alice，您可以

def apply(elems: (String, Any)*): Person

在伴随对象中定义：。如果 Any 太宽松，您可以定义 PersonElem 特征，

def apply(elems: (String, PersonElem)*): Person

以及 String、Map[String, String] 之间的隐式转换code>、Person 等到 PersonElem。

Answer 2

这让你几乎成功了。还有一张地图我无法轻易摆脱。

基本方法是拥有一个有点人为的参数类型，它继承自通用类型。这样，apply 方法只需要一个 vararg。

使用隐式转换方法，我摆脱了参数类型的丑陋构造函数

case class Child

case class Person(stringParms: Map[String, String],
    mapParms: Map[String, Map[String, String]],
    children: List[Child]) { }

sealed abstract class PersonParameter 
case class MapParameter(tupel: (String, Map[String, String])) extends PersonParameter 
case class StringParameter(tupel: (String, String)) extends PersonParameter 
case class ChildParameter(child: Child) extends PersonParameter

object Person {
    def apply(params: PersonParameter*): Person = {

        var stringParms = Map[String, String]()
        var mapParms = Map[String, Map[String, String]]()
        var children = List[Child]()
        for (p ← params) {
            p match {
                case StringParameter(t) ⇒ stringParms += t
                case MapParameter(t) ⇒ mapParms += t
                case ChildParameter(c) ⇒ children = c :: children
            }
        }
        new Person(stringParms, mapParms, children)
    }
    implicit def tupel2StringParameter(t: (String, String)) = StringParameter(t)
    implicit def child2ChildParameter(c: Child) = ChildParameter(c)
    implicit def map2MapParameter(t: (String, Map[String, String])) = MapParameter(t)

    def main(args: Array[String]) {
        val firstChild = Child()
        val secondChild = Child()
        val bob: Person = Person("name" -> "Bob","pets" -> Map("cat" -> "Mittens", "dog" -> "Spot"),"status"
-> "asleep", 
        firstChild, secondChild)

        println(bob)
    } }

Answer 3

这是一种方法：

sealed abstract class PersonParam
object PersonParam {
    implicit def toTP(tuple: (String, String)): PersonParam = new TupleParam(tuple)
    implicit def toMap(map: (String, Map[String, String])): PersonParam = new MapParam(map)
    implicit def toSP(string: String): PersonParam = new StringParam(string)
}

class TupleParam(val tuple: (String, String)) extends PersonParam
class MapParam(val map: (String, Map[String, String])) extends PersonParam
class StringParam(val string: String) extends PersonParam

class Person(params: PersonParam*) {
    val stringParams = Map(params collect { case parm: TupleParam => parm.tuple }: _*)
    val mapParams = Map(params collect { case parm: MapParam => parm.map }: _*)
    val children = params collect { case parm: StringParam => parm.string } toList
}

用法：

scala> val bob = new Person("name" -> "Bob",
     | "pets" -> Map("cat" -> "Mittens", "dog" -> "Spot"),
     | "status" -> "asleep",
     | "little bob", "little ann")
bob: Person = Person@5e5fada2

scala> bob.stringParams
res11: scala.collection.immutable.Map[String,String] = Map((name,Bob), (status,asleep))

scala> bob.mapParams
res12: scala.collection.immutable.Map[String,Map[String,String]] = Map((pets,Map(cat -> Mittens, dog -> Spot)))

scala> bob.children
res13: List[String] = List(little bob, little ann)