0

アプリ全体で複数回 (15 回以上) 繰り返されるこのコードがあります。

val entityList = params.map(paramPair => {
//THIS LINE DEPENDS ON THE ENTITY
val entityX = new Entity1
paramPair.foreach { case (key, value) => (key, value) match {
  //THIS BLOCK CHANGES DEPENDING THE ENTITY
  case (KEY1, v: TYPE1) => entityX setX v
  case (KEY2, v: TYPE2) => entityX setY v
  ...
  //END BLOCK
  case _ =>
  }
}
entityX
})

変更される唯一のコードは、エンティティのタイプとパターン マッチングの case 句です。コードの繰り返しを避けるために、これらのケースを受け取る関数を作成する方法はありますか?

4

2 に答える 2

1

ただ楽しみのために。楽しむことがポイントだからですよね？

可変フィールドの使い方を忘れてしまったので、不変の犬を作るのが好きです。

偽装者は、PartialFunctionをリファクタリングすることでAnyValを拡張できます（匿名のネストされたクラスはAnyValで許可されていないため、「この制限は今後のリリースで削除される予定です。」）

package populate

import scala.reflect._
import scala.reflect.runtime.{ currentMirror => cm }
import scala.reflect.runtime.universe._
import java.util.{ Calendar, Date }

case class Person(var name: String, var birth: Date) { def this() = this(null,null) }
case class Book(var title: String, var pub: Date) { def this() = this(null,null) }
case class Dog(val name: String, val rabies: Date, val goodBoy: Boolean = true)

object Test extends App {
  def dateOf(y:Int,m:Int,d:Int) = { val c = Calendar.getInstance; c.set(1974, 2, 14); c.getTime }
  val input = Seq("id" -> "Sybil", "n" -> dateOf(1974, 2, 14), "garbage" -> "error")

  trait Completer[A] extends Any {
    def filler: PartialFunction[A, Unit]
    def complete(info: Seq[A]) = info foreach (filler orElse {
      case (k, v)             => println(s"Can't use $k -> $v")
    })
  }
  type Info = (String, Any)
  implicit class Impersonator(val p: Person) extends Completer[Info] {
    override def filler = {
      case ("id", s: String)  => p.name = s
      case ("n", d: Date)     => p.birth = d
    }
  }
  implicit class Booker(val b: Book) extends Completer[Info] {
    override def filler = {
      case ("id", s: String)  => b.title = s
      case ("n", d: Date)     => b.pub = d
    }
  }

  def personify(p: Person, info: Seq[(String, Any)]) = info foreach {
    case ("id", s: String)  => p.name = s
    case ("n", d: Date)     => p.birth = d
    case (k, v)             => println(s"Can't use $k -> $v")
  }
  def bookish(b: Book, info: Seq[(String, Any)]) = info foreach {
    case ("id", s: String)  => b.title = s
    case ("n", d: Date)     => b.pub = d
    case (k, v)             => println(s"Can't use $k -> $v")
  }
  def inject[A: ClassTag](a: A, info: Seq[(String, Any)]): A = {
   implicitly[ClassTag[A]] match {
    case ClassTag(k) if k == classOf[Person]  => personify(a.asInstanceOf[Person], info)
    //case ClassTag(k) if k == classOf[Book]    => bookish(classOf[Book] cast a, info)
    case ClassTag(k) if k == classOf[Book]    => a.asInstanceOf[Book] complete info
    case k => println(s"Unknown $k")
   }
   a
  }
  def entity[A: ClassTag](info: Seq[(String, Any)]): A = {
    val e = implicitly[ClassTag[A]].runtimeClass.newInstance.asInstanceOf[A]
    inject(e, info)
  }

  val v = entity[Person](input)
  println(v)
  Console println entity[Book](input)

  Console println Defaulter((input map {
    case ("id", v)  => ("name", v)
    case ("n", v)   => ("rabies", v)
    case p          => p
  }).toMap).newCase[Dog]
}

case class Defaulter(input: Map[String, Any]) {
  def newCase[A]()(implicit t: ClassTag[A]): A = {
    val claas = cm classSymbol t.runtimeClass
    val modul = claas.companionSymbol.asModule
    val im = cm reflect (cm reflectModule modul).instance
    defaut[A](im, "apply")
  }

  def defaut[A](im: InstanceMirror, name: String): A = {
    val at = newTermName(name)
    val ts = im.symbol.typeSignature
    val method = (ts member at).asMethod

    // either defarg or default val for type of p
    def valueFor(p: Symbol, i: Int): Any = {
      val defarg = ts member newTermName(s"$name$$default$$${i+1}")
      if (input contains p.name.toString) {
        input(p.name.toString)
      } else if (defarg != NoSymbol) {
        println(s"default $defarg")
        (im reflectMethod defarg.asMethod)()
      } else {
        println(s"def val for $p")
        p.typeSignature match {
          case t if t == typeOf[String] => null
          case t if t == typeOf[Int]    => 0
          case t if t == typeOf[Date]   => new Date(0L)
          case x                        => throw new IllegalArgumentException(x.toString)
        }
      }
    }
    val args = (for (ps <- method.paramss; p <- ps) yield p).zipWithIndex map (p => valueFor(p._1,p._2))
    (im reflectMethod method)(args: _*).asInstanceOf[A]
  }
}
于 2012-12-27T05:19:08.090 に答える
1

あなたは回すことができます

paramPair.foreach { case (key, value) => (key, value) match {
  //THIS BLOCK CHANGES DEPENDING THE ENTITY
  case (KEY1, v: TYPE1) => entityX setX v
  case (KEY2, v: TYPE2) => entityX setY v
  ...
  //END BLOCK
  case _ =>
  }
}

の中へ

paramPair.foreach { case (key, value) => 
  case (KEY1, v: TYPE1) => entityX setX v
  case (KEY2, v: TYPE2) => entityX setY v
  ...
  //END BLOCK
  case _ =>
  }
}

匿名クラスに問題がなければ、さらにコード全体を次のように変換できます。

val entityList = params.map(paramPair => {
  new Entity1 {
    paramPair.foreach { case (key, value) => 
      //THIS BLOCK CHANGES DEPENDING THE ENTITY
      case (KEY1, v: TYPE1) => setX v
      case (KEY2, v: TYPE2) => setY v
      ...
      //END BLOCK
      case _ =>
    }
}})

エンティティに応じてブロックが変更される場合、@pst が言ったように、いわゆる関数リテラルを使用して関数に変換できます: 中括弧と case ステートメントを含む式は PartialFunction に変換されます。

val fillEntitityOne: PartialFunction[A,B] = {
  case (KEY1, v: TYPE1) => entityX setX v
  case (KEY2, v: TYPE2) => entityX setY v
}

A と B の入力と戻り値の型、たとえば

val foobar: Int => String = { case 1 => "1" }

そのため、2 番目のスニペットで一致部分を省略できます。 foreach は Function インスタンス (および PartialFunction は Function から継承) を想定しているため、もちろんいくつかの型で、実際に脱糖できます。

.foreach {
  case x => 
}

の中へ

.foreach({
  case x => 
})

その後

val anon = new PartialFunction[A,B]{....}
.foreach(anon)
于 2012-12-26T20:54:17.297 に答える