Liste von Scala ' s "magic" - Funktionen

Wo finde ich eine Liste von Scala ' s "magic" - Funktionen, wie apply, unapply, update, += usw.?

Durch Magie-Funktionen meine ich Funktionen, die verwendet werden, von einigen syntaktischer Zucker des Compilers, zum Beispiel

o.update(x,y) <=> o(x) = y

Habe ich gegoogelt bei einigen Kombinationen scala magic und Synonyme zu functions, aber ich habe nichts gefunden.

Ich bin nicht daran interessiert, mit der Nutzung von magic-Funktionen in der standard-Bibliothek, sondern in die Magie Funktionen besteht.

InformationsquelleAutor Elazar Leibovich | 2009-09-27
  1. 77

    Soweit ich weiß:

    Getter/setter Verwandte:

    apply
update
identifier_=

    Pattern-matching:

    unapply
unapplySeq

    Für-Verstehens:

    map
flatMap
filter
withFilter
foreach

    Präfix-Operatoren:

    unary_+
unary_-
unary_!
unary_~

    Darüber hinaus eine implizite von A nach B. Scala wird auch konvertieren A <op>= B in A = A <op> B, wenn der ehemalige Betreiber ist nicht definiert, "op" ist kein alphanumerisches Zeichen, und <op>= ist nicht !=, ==, <= oder >=.

    Und ich glaube nicht, dass es keinen einzelnen Ort, wo alle von Scala ist syntaktischer Zucker aufgeführt sind.

    • Möglicherweise möchten Sie die unary_! etc. Operatoren, die waren aufgelistet, die in einem der anderen Beiträge, da diese aussieht wie die erschöpfende Antwort auf die Frage hier 🙂
    • Was identifier_=? Nie gesehen.
    • Versuchen Sie dies: object X { var _x = 0; def x_=(n: Int) { _x = n }; def x = _x }; X.x = 5; println(X.x)
    • C. Sobral: Ah, OK, identifier war nur dazu gedacht, ein Platzhalter. Es bekam. Danke.
    • Naja, da ist jetzt ein Platz 😉
    • Können Sie fügen Sie eine kurze Erläuterung/Verwendungen dieser auch?
    • Es gibt auch equals aufgerufen wird ==

    InformationsquelleAutor Daniel C. Sobral
  2. 16

    Neben update und apply gibt es auch eine Reihe von unären Operatoren, die (ich glaube) qualifizieren sich als magisch:

    • unary_+
    • unary_-
    • unary_!
    • unary_~

    Hinzufügen, dass die regelmäßige infix/suffix-Operatoren (das kann fast alles sein) und Sie haben sich das komplette Paket.

    Sollten Sie wirklich einen Blick auf die Scala Language Specification. Es ist die einzige maßgebliche Quelle auf diesem Zeug. Es ist nicht schwer zu Lesen (solange Sie bequem sind mit Kontext-freien Grammatiken), und sehr einfach durchsuchbar. Das einzige, was es nicht geben, ist die XML-Unterstützung.

    InformationsquelleAutor Daniel Spiewak
  3. 11

    Sorry, wenn es nicht genau deine Frage zu beantworten, aber mein Lieblings-WTF-moment, so weit ist @ als Zuweisungsoperator inneren Muster entsprechen. Dank soft-copy von "Programming in Scala" fand ich heraus, was es war ziemlich schnell.

    Mit @ können wir binden Sie alle Teil eines Musters, um eine variable, und wenn Sie den pattern-match erfolgreich ist, wird die variable erfassen den Wert der sub-Muster. Hier ist das Beispiel von Programmierung in Scala (Abschnitt 15.2 - Variable Bindung):

    expr match {
  case UnOp("abs", e @ UnOp("abs", _)) => e
  case _ =>
}

    Wenn die gesamte pattern-match erfolgreich ist,
    dann der Teil, der auf das
    UnOp("abs", _) Teil zur Verfügung gestellt wird
    als variable e.

    Und hier's was Programmierung Scala dazu sagt.

    Der link funktioniert nicht mehr. Hier ist eine, die funktioniert.

    • Können Sie uns mitteilen, was uns der @ - operator funktioniert?
    • Ja, nur bearbeitet meine Antwort 🙂
    InformationsquelleAutor Yardena
  4. 3

    Werde ich auch hinzufügen _* für pattern matching auf eine beliebige Anzahl von Parametern wie

    case x: A(_*)

    Und operator Assoziativität in der Regel von Odersky-Löffel-Venners Buch:

    Die Assoziativität eines operators in Scala ist bestimmt durch den letzten
    Charakter. Wie bereits erwähnt, <...>, jede Methode, die enden
    in einem ': '- Zeichen aufgerufen wird, die auf der rechten Operanden, übergeben
    linken Operanden. Methoden, die in jedem anderen Charakter sind den anderen
    Weg herum. Sie sind aufgerufen, auf Ihren linken Operanden, übergeben
    Rechte operand ist. Also a * b ergibt.*(b), aber a ::: b ergibt b.:::(a).

    Vielleicht sollten wir auch erwähnen, syntaktische desugaring von für Ausdrücke, die gefunden werden können hier

    Und (natürlich!), alternative syntax für Paare

    a -> b //converted to (a, b), where a and b are instances

    (wie korrekt darauf hingewiesen, dies ist nur ein implizite Konvertierung erfolgt durch eine Bibliothek, so ist es wohl nicht berechtigt, aber ich finde es ist eine gemeinsame Puzzle für Neulinge)

    • IIRC -> ist nur eine library-Funktion.
    InformationsquelleAutor pagoda_5b
  5. 3

    Definiert sind Sie in der Scala Language Specification.
    Soweit ich weiß, gibt es nur drei "magischen" Funktionen, wie Sie erwähnt.

    Scalas Getter und Setter kann auch beziehen sich auf Ihre "Magie":

    scala> class Magic {
 |     private var x :Int = _
 |     override def toString = "Magic(%d)".format(x)
 |     def member = x
 |     def member_=(m :Int){ x = m }
 | }

defined class Magic

scala> val m = new Magic

m: Magic = Magic(0)

scala> m.member

res14: Int = 0

scala> m.member = 100

scala> m

res15: Magic = Magic(100)

scala> m.member += 99

scala> m

res17: Magic = Magic(199)
    • Wenn Sie Graben für mich ein Beweis für die, die behaupten, Sie werden die Beantwortung meiner Frage 😉 ich nahm an, es werde in den specs, aber finden Sie es nicht ein Spaß job.
    • Scala Language Specification: 6.15 Aufgaben ..., Wenn x einen parameterlosen Funktion definiert, die in einigen Vorlagen, und die gleiche Vorlage enthält eine setter-Funktion x_= als Mitglied hat, dann die Zuweisung x = e wird interpretiert als die Anrufung x_=(e), die setter-Funktion. Analog ist eine Zuordnung f .x = e zu einer parameterlosen Funktion x wird interpretiert als der Aufruf f .x_=(e ). Eine Zuordnung f (args) = e eine Funktion, mit der Anwendung auf der linken Seite des " = " operator interpretiert wird, als f -.update(args, e ), d.h. der Aufruf einer update-Funktion definiert durch f .
    • Ich ment, Beweise, dass es sich nicht mehr.
    InformationsquelleAutor Eastsun
  6. 3

    Möchte ich hinzufügen, dass es auch eine "Magische" Eigenschaft - scala.Dynamic:

    Marker-Merkmal, das es ermöglicht, dynamische Aufrufe. Instanzen x dieses Merkmals ermöglichen Methodenaufrufe x.meth(args) für beliebige Methodennamen meth - argument-Listen args sowie Feld-Zugriffe x.field für beliebige Feldnamen field.

    Wenn ein Anruf nicht nativ unterstützt von x (d.h. wenn die Typprüfung fehlschlägt), es wird neu geschrieben nach den folgenden Regeln:

    foo.method("blah")      ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah")  ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2)    ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field           ~~> foo.selectDynamic("field")
foo.varia = 10      ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13    ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10)         ~~> foo.applyDynamic("arr")(10)

    Ab Scala 2.10, die Festlegung direkten oder indirekten Unterklasse für dieses Merkmal ist nur möglich, wenn die Sprache, Funktion, Dynamik aktiviert ist.

    So können Sie die Sachen tun, wie

    import scala.language.dynamics

object Dyn extends Dynamic {
  def applyDynamic(name: String)(a1: Int, a2: String) {
    println("Invoked " + name + " on (" + a1 + "," + a2 + ")");
  }
}

Dyn.foo(3, "x");
Dyn.bar(3, "y");
    • Der link funktioniert nicht. Können Sie aktualisieren?
    InformationsquelleAutor Petr Pudlák
Schreibe einen Kommentar