Warum ist die `unary_ " - Präfix benötigt in scala?

Anfänger Scala Frage, aber ich konnte nicht finden die Antwort hier.

Ähnlich überladen in C++, ich würde erwarten, dass der compiler kann sagen, der Unterschied zwischen einer Methode namens - nimmt einen parameter (mit dem gleichen Typ wie die Klasse) und die unären version von - die keine Parameter hat, also warum ist unary_ benötigt?

InformationsquelleAutor jhabbott | 2013-05-20

scala

70

Den unary_ Präfix für unäre Präfix-Operatoren ist ein wenig irreführend: es geht mehr um die Präfix Teil als die unäre Teil. Benötigen Sie eine Möglichkeit, zu unterscheiden,
```
!foo //unary prefix !
```
vom
```
foo! //unary postfix !
```
Denken Sie daran: Scala tatsächlich nicht die Betreiber. Es gibt zwei Möglichkeiten zum aufrufen einer Methode, entweder mit einem . oder mit Leerzeichen:
```
foo.bar(1, "two")
foo bar(1, "two")
```
Und wenn Sie haben, ein einzelnes argument, Sie können lassen Sie die Klammern:
```
foo plus(1)
foo plus 1
```
Schließlich (fast) alle Charakter ist legal in einem identifier:
```
foo plus 1
foo + 1
```
Nun sieht wie das Scala hat ein binärer infix - + Betreiber, aber es eigentlich gar nicht. Es ist nur eine normale Methode aufgerufen, mit der normalen Methode aufrufen syntax.

Was ich oben sagte ist nicht voll wahr, jedoch. Wenn die Scala hat keine Unterstützung für die Operatoren und es war alles nur normale Methode aufrufen, dann
```
2 + 3 * 4
```
bewerten würde um die 20 (wie in Smalltalk Selbst und Neusprech zum Beispiel) anstelle von 14. Also, es ist eine wenig bit-Unterstützung für Operatoren in Scala (zwei kleine Stückchen, eigentlich). Wenn eine Methode aufgerufen wird mit Leerzeichen (sogenannten "operator-syntax") anstelle der ., und die Methode beginnt mit einem operator-Zeichen, dann Scala respektieren Rangfolge.

Und die anderen wenig-operator-Unterstützung ist, dass es einige Operatoren, die Sie würde wie zu haben, aber das ist nicht einfach, ausgedrückt als eine Methode aufrufen. Es funktioniert gut für binäre infix-Operatoren und unären postfix-Operatoren:
```
foo op bar //same as:
foo.op(bar)

foo op     //same as:
foo.op
```
Aber nicht für "Präfix" oder "rund-um-fix" - Betreiber:
```
!foo
foo(bar)
```
So, es gibt ein paar spezielle syntaktische Zucker-übersetzung-Regeln:
```
!foo
foo.unary_!
//same for +, - and ~

foo(bar)
foo.apply(bar)

foo(bar) = 1
foo.update(bar, 1)

foo += 1
foo.+=(1) //but if this doesn't compile, then the compiler will also try
foo = foo.+(1)
```
Und der Grund, warum es muss ein Unterstrich zwischen dem alphanumerischen und dem "operator" - Teil im Namen einer Methode ist, weil Sie nicht weiß, ob
```
foo!
```
bedeutet
```
foo.!
```
oder
```
this.foo!
```
So foo! als den Namen einer Methode ist illegal, es muss aufgerufen werden foo_!.
- Vielen Dank für die ausführliche Erklärung und zusätzliche Einblicke 🙂
- Da diese Antwort scheint zu sammeln, einige Aufmerksamkeit: da ist einer ein bisschen Methodenaufruf syntax-Zucker, die ich bin fehlt?
- "Wenn eine Methode aufgerufen wird mit Leerzeichen (sogenannten "operator-syntax") statt ., und die Methode beginnt mit einem operator-Zeichen, dann Scala respektieren Betreiber Vorrang." @jhabbott schau dir das an: scala> 2.+3.*4 res10: Double = 14.0
- Sie sind mit operator-syntax in diesem Fall. Es wird interpretiert als (2.) + (3.) * (4). Sie sollten eine deprecation-Warnung, obwohl; float Literale ohne Dezimalstellen sind veraltet und werden entfernt in späteren Versionen.
InformationsquelleAutor Jörg W Mittag
9

Da in scala ist es völlig in Ordnung, erstellen Sie eine Methode mit dem Namen -, das braucht keine Argumente. Wie würden Sie unterscheiden zwischen einer normalen und einer einfachen Methode? Zum Beispiel ! hat eine ganz andere Bedeutung als einfach, als als post-Update-operator.
- So können Sie !x und x! beide gerade genannt ! und nehmen keine weiteren Parameter und der compiler weiß, dass es zwei verschiedene Funktionen? Auch er wird wissen, was man zu nennen, weil es vor oder nach dem Objekt?
- Jörg W Mittag erklärt in einem kleinen detail, was ich sagen wollte mit meiner Antwort 😉
- Ja danke - Sie beide bekommen upvotes 🙂 ich bin nur zu lernen, und einige Dinge, die schwierig sind zu verstehen, wenn Sie nicht wissen, über all die anderen Dinge noch nicht.
InformationsquelleAutor drexin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.