在Scala中将动态对象与结构化类型混合

Question

Is it possible to do this? (I'm using scala 2.10) To call a method that requires that the object has a function named "fullName", but the object being built with the Dynamic trait. The compiler complains, but maybe I'm doing it wrong.

I don't need this for any job, I'm just learning the language.

import scala.language.dynamics

object Main extends App {

    class MyStatic {

        private var privateName = ""
        var lastName = ""

        def name_= (n: String) {
            privateName = n
        }

        def name = s"***$privateName***"

        def fullName = s"$name $lastName"

    }

    class MyDynamic extends scala.Dynamic {

        val map = collection.mutable.Map[String, String]()

        def selectDynamic(key: String): String = map(key)

        def updateDynamic(key: String)(value: String) {
            map += key -> value
        }

        def applyDynamic(key: String)(value: Any*) = key match {
            case "fullName" => {
                val name = map("name")
                val lastName = map("lastName")
                s"$name $lastName"
            }
        }

    }

    def showFullName(o: { def fullName: String }) = s"My full name is $o.fullName"

    println("Starting App...")

    val s = new MyStatic
    s.name = "Peter"
    s.lastName = "Parker"
    println(showFullName(s))

    val d = new MyDynamic
    d.name = "Bruce"
    d.lastName = "Wayne"
    println(showFullName(d))

}

Answer 1

The structural type { def fullName: String } basically means "any type with a no-arg method named fullName returning a String . MyDynamic has no such method, and thus does not comply with this structural type. The fact that MyDynamic extends scala.Dynamic is irreleveant: it means that for any instance of it, you can perform what looks like a call to fullName , but it does not mean that MyDynamic (as a type) has any such member.

So the short answer is no , you cannot mix dynamic objects with structural typing like that.

For completeness, I must add that it could be made to work as you expected, but it would require a special provision from the compiler (namely, the compiler could consider than any type extending scala.Dynamic -- and implementing the required lookup methods -- is compatible with any structural typing, and implement the call not via reflection as is normally done, but by calling the corresponding lookup method).

Answer 2

You are trying to glue together two completely different things. While structural typing is also sometimes compared to 'duck-typing', its feature is exactly the use of static type information (even if on the use site the byte code will call reflection). Per definition, your dynamic type does not have such static type information. So you will never be able to convince the Scala compiler that your dynamic type has a method that can be statically verified to exist.

The only workaround would be to allow any type in showFullName and use reflection to call fullName (again, I'm not sure if this plays out with a dynamic object).

---

On the other hand, Scala will let you do anything with dynamic types, handing the responsibility over to you:

def showFullName(o: Dynamic) = s"My full name is $o.fullName"

println(showFullName(d))