用于Scala中安全导航运算符的DSL

Question

我想构建一个Scala DSL以将Java POJO的现有结构转换为等效于Map的结构。

但是，传入对象结构很可能包含大量空引用，这将导致输出映射中没有值。

在这方面的表现非常重要，所以我需要避免反射和抛/ NPE。

我已经认为已经不符合我的要求this topic。

我认为答案可能在于使用宏来生成一些特殊的类型，但我没有使用scala宏的经验。

更正式地说：由项目提供

POJO类：（会有像50 POJO，嵌套的，所以我想这并不需要手工编写和维护他们每一类或性状的解决方案）

case class Level1(
    @BeanProperty var a: String, 
    @BeanProperty var b: Int) 

    case class Level2(
    @BeanProperty var p: Level1, 
    @BeanProperty var b: Int) 

预期的行为：

println(convert(null)) // == Map() 
    println(convert(Level2(null, 3))) // == Map("l2.b" -> 3) 
    println(convert(Level2(Level1("a", 2), 3))) // == Map(l2.p.a -> a, l2.p.b -> 2, l2.b -> 3) 

正确执行，但我想一个更简单的DSL写的映射

implicit def toOptionBuilder[T](f: => T) = new { 
    def ? : Option[T] = Option(f) 
    } 

def convert(l2: Level2): Map[String, _] = l2? match { 
    case None => Map() 
    case Some(o2) => convert(o2.p, "l2.p.") + ("l2.b" -> o2.b) 
    } 

    def convert(l1: Level1, prefix: String = ""): Map[String, _] = l1? match { 
    case None => Map() 
    case Some(o1) => Map(
     prefix + "a" -> o1.a, 
     prefix + "b" -> o1.b) 
    } 

这里是我想用一个DSL写：“？”

def convertDsl(l2:Level2)={ 
     Map(
      "l2.b" -> l2?.b, 
      "l2.p.a" -> l2?.l1?.a, 
      "l2.p.b" -> l2?.l1?.b 
     ) 
    } 

请注意，这是完全正常，我指定的属性是可选的。 我想要的是使用宏来静态生成一个方法l2.?l1或l2？.l1，它返回Option [Level1]（因此类型检查在我的DSL中正确完成）。

Answer 1

我不能完善它下来正是你上面给的，但通常，这样的事情可能工作的语法：

sealed trait FieldSpec 

sealed trait ValueFieldSpec[+T] extends FieldSpec 
{ 
    def value: Option[T] 
} 

case class IntFieldSpec(value: Option[Int]) extends ValueFieldSpec[Int] 
case class StringFieldSpec(value: Option[String]) extends ValueFieldSpec[String] 

case class Level1FieldSpec(input: Option[Level1]) extends FieldSpec 
{ 
    def a: ValueFieldSpec[_] = StringFieldSpec(input.map(_.a)) 
    def b: ValueFieldSpec[_] = IntFieldSpec(input.map(_.b)) 
} 

case class Level2FieldSpec(input: Option[Level2]) extends FieldSpec 
{ 
    def b: ValueFieldSpec[_] = IntFieldSpec(input.map(_.b)) 
    def l1 = Level1FieldSpec(input.map(_.p)) 
} 

case class SpecArrowAssoc(str: String) 
{ 
    def ->(value: ValueFieldSpec[_]) = (str, value) 
} 

implicit def str2SpecArrowAssoc(str: String) = SpecArrowAssoc(str) 

implicit def Level2ToFieldSpec(input: Option[Level2]) = Level2FieldSpec(input) 

def map(fields: (String, ValueFieldSpec[_])*): Map[String, _] = 
    Map[String, Any]((for { 
    field <- fields 
    value <- field._2.value 
    } yield (field._1, value)):_*) 

def convertDsl(implicit l2: Level2): Map[String, _] = 
{ 
    map(
    "l2.b" -> l2.?.b, 
    "l2.p.a" -> l2.?.l1.a, 
    "l2.p.b" -> l2.?.l1.b 
) 
} 

然后我们得到：

scala> val myL2 = Level2(Level1("a", 2), 3) 
myL2: Level2 = Level2(Level1(a,2),3) 

scala> convertDsl(myL2) 
res0: scala.collection.immutable.Map[String,Any] = Map(l2.b -> 3, l2.p.a -> a, l2.p.b -> 2) 

注意，DSL使用'？'而不仅仅是'？'作为我可以看到Scala在分号推理和后缀运算符方面遇到困难的唯一方式（例如，请参阅@ 0__对scala syntactic suger question的回答）。

此外，您可以提供的字符串是任意的（不对其进行检查或解析），而这个简单化的'FieldSpec'层次结构将假定所有POJO对字符串字段使用'a'，对Int使用'b'领域等

有一点时间和精力，我相信这可以改善。