Hat eine Sprache einen unären booleschen Umschaltoperator?

Das ist also eher eine theoretische Frage. C ++ und direkt darauf basierende Sprachen (in) (Java, C #, PHP) verfügen über Verknüpfungsoperatoren , mit denen das Ergebnis der meisten Binäroperatoren dem ersten Operanden zugewiesen werden kann, z

a += 3;   // for a = a + 3
a *= 3;   // for a = a * 3;
a <<= 3;  // for a = a << 3;

Aber wenn ich einen booleschen Ausdruck umschalten möchte, schreibe ich immer so etwas

a = !a;

was nervt wenn aein langer ausdruck ist wie.

this.dataSource.trackedObject.currentValue.booleanFlag =
    !this.dataSource.trackedObject.currentValue.booleanFlag;

(Ja, Demeters Gesetz, ich weiß).

Also ich frage mich, ist es eine Sprache mit einem unären boolean Toggle Operator , der mich abzukürzen erlauben würde , a = !aohne Wiederholung der Ausdruck für a, zum Beispiel

!=a;  
// or
a!!;

Nehmen wir an, dass unsere Sprache einen richtigen booleschen Typ hat (wie boolin C ++) und dass adieser vom Typ ist (also kein C-Stil int a = TRUE).

Wenn Sie eine dokumentierte Quelle finden, würde mich auch interessieren, ob beispielsweise die C ++ - Designer erwogen haben, einen solchen Operator hinzuzufügen, als er boolzu einem integrierten Typ wurde, und wenn ja, warum sie sich dagegen entschieden haben.

(Anmerkung: Ich weiß , dass einige Leute der Meinung sind , dass Zuordnung nicht verwenden sollten , =und dass ++und +=sind nicht nützlich Betreiber aber Design - Fehler, lassen Sie uns einfach davon ausgehen , ich bin glücklich mit ihnen und konzentrieren sich auf , warum sie bools nicht verlängern würde).

Diese Frage ist in der Tat aus rein theoretischer Sicht interessant. Abgesehen davon, ob ein unärer, mutierender boolescher Umschaltoperator nützlich wäre oder nicht , oder warum sich viele Sprachen dafür entschieden haben, keinen bereitzustellen, wagte ich mich auf die Suche, ob er tatsächlich existiert oder nicht.

TL; DR anscheinend nein, aber mit Swift können Sie eine implementieren. Wenn Sie nur sehen möchten, wie es gemacht wird, können Sie zum Ende dieser Antwort scrollen.

Nach einer (schnellen) Suche nach Funktionen verschiedener Sprachen kann ich mit Sicherheit sagen, dass keine Sprache diesen Operator als streng mutierende In-Place-Operation implementiert hat (korrigieren Sie mich, wenn Sie eine finden). Als nächstes sollten Sie also prüfen, ob es Sprachen gibt, mit denen Sie eine erstellen können. Was dies erfordern würde, sind zwei Dinge:

1. in der Lage sein, (unäre) Operatoren mit Funktionen zu implementieren
2. Ermöglichen, dass diese Funktionen Referenzargumente haben (damit sie ihre Argumente direkt mutieren können)

Viele Sprachen werden sofort ausgeschlossen, wenn sie eine oder beide dieser Anforderungen nicht unterstützen. Java erlaubt keine Überladung von Operatoren (oder benutzerdefinierte Operatoren) und außerdem werden alle primitiven Typen als Wert übergeben. Go unterstützt keinerlei Überlastung des Bedieners (außer durch Hacks ). Rust erlaubt nur das Überladen von Bedienern für benutzerdefinierte Typen. Sie könnten dies in Scala fast erreichen , wodurch Sie sehr kreativ benannte Funktionen verwenden und auch Klammern weglassen können, aber leider gibt es keine Referenzübergabe. Fortran kommt dem sehr nahe, da es benutzerdefinierte Operatoren zulässt, ihnen jedoch ausdrücklich verbietet, Inout zu haben Parameter (die in normalen Funktionen und Unterprogrammen zulässig sind).

Es gibt jedoch mindestens eine Sprache, die alle erforderlichen Kästchen ankreuzt: Swift . Während einige Leute auf die bevorstehende .toggle () -Mitgliedsfunktion verlinkt haben , können Sie auch Ihren eigenen Operator schreiben, der tatsächlich inout- Argumente unterstützt . Siehe da:

prefix operator ^

prefix func ^ (b: inout Bool) {
    b = !b
}

var foo = true
print(foo)
// true

^foo

print(foo)
// false

Das Boolesche Bit umschalten

... das würde mir erlauben, abzukürzen, a = !a ohne den Ausdruck füra ...

Dieser Ansatz ist nicht wirklich ein reiner "mutierender Flip" -Operator, erfüllt jedoch die oben genannten Kriterien. Die rechte Seite des Ausdrucks enthält nicht die Variable selbst.

Jede Sprache mit einer booleschen XOR-Zuweisung (z. B. ^=) würde das Umdrehen des aktuellen Werts einer Variablen ermöglichen, z. B. amittels XOR-Zuweisung an true:

// type of a is bool
a ^= true;  // if a was false, it is now true,
            // if a was true, it is now false

Wie von @cmaster in den Kommentaren unten ausgeführt, wird davon ausgegangen, dass aes sich um einen Typ boolhandelt und nicht um eine Ganzzahl oder einen Zeiger. Wenn aes sich tatsächlich um etwas anderes handelt (z. B. um etwas, das nicht boolauf einen "wahrheitsgemäßen" oder "falschen" Wert bewertet wird, mit einer Bitdarstellung, die nicht 0b1bzw. 0b0ist), gilt das Obige nicht.

Für ein konkretes Beispiel ist Java eine Sprache, in der dies genau definiert ist und keine stillen Konvertierungen vorgenommen werden. Zitat von @ Boanns Kommentar von unten:

In Java ^und ^=haben explizit definiertes Verhalten für Boolesche Werte und für Ganzzahlen ( 15.22.2. Boolesche logische Operatoren &, ^und| ), wobei entweder beide Seiten des Operators Boolesche Werte oder beide Seiten Ganzzahlen sein müssen. Es gibt keine stille Konvertierung zwischen diesen Typen. Es wird also nicht stillschweigend zu Fehlfunktionen kommen, wenn aes als Ganzzahl deklariert wird, sondern es wird ein Kompilierungsfehler ausgegeben. Ist a ^= true;also sicher und gut definiert in Java.

Schnell: toggle()

Ab Swift 4.2 wurde der folgende Evolutionsvorschlag akzeptiert und umgesetzt:

• SE-0199: Hinzufügen eines Umschalters zu Bool

Dies fügt toggle()dem BoolTyp in Swift eine native Funktion hinzu .

toggle()

Schaltet den Wert der Booleschen Variablen um.

Erklärung

mutating func toggle()

Diskussion

Verwenden Sie diese Methode, um einen Booleschen Wert von truenach falseoder von falsenach umzuschalten true.

var bools = [true, false]

bools[0].toggle() // bools == [false, false]

Dies ist per se kein Operator, ermöglicht jedoch einen sprachlichen Ansatz für das boolesche Umschalten.

In C ++ ist es möglich, die Hauptsünde der Neudefinition der Bedeutung von Operatoren zu begehen. In diesem Sinne und mit ein wenig ADL müssen wir nur Folgendes tun, um Chaos auf unserer Benutzerbasis auszulösen:

#include <iostream>

namespace notstd
{
    // define a flag type
    struct invert_flag {    };

    // make it available in all translation units at zero cost
    static constexpr auto invert = invert_flag{};

    // for any T, (T << invert) ~= (T = !T)    
    template<class T>
    constexpr T& operator<<(T& x, invert_flag)
    {
        x = !x;
        return x;
    }
}

int main()
{
    // unleash Hell
    using notstd::invert;

    int a = 6;
    std::cout << a << std::endl;

    // let confusion reign amongst our hapless maintainers    
    a << invert;
    std::cout << a << std::endl;

    a << invert;
    std::cout << a << std::endl;

    auto b = false;
    std::cout << b << std::endl;

    b << invert;
    std::cout << b << std::endl;
}

erwartete Ausgabe:

6
0
1
0
1

Solange wir Assemblersprache enthalten ...

FORTH

INVERT für eine bitweise Ergänzung.

0= für eine logische (wahr / falsch) Ergänzung.

Das Dekrementieren eines C99 boolhat den gewünschten Effekt, ebenso wie das Inkrementieren oder Dekrementieren der bitTypen, die in einigen Dialekten mit winzigen Mikrocontrollern unterstützt werden (die, wie ich beobachtet habe, Bits als ein Bit breite Bitfelder behandeln, sodass alle geraden Zahlen auf 0 und alle abgeschnitten werden ungerade Zahlen zu 1). Ich würde eine solche Verwendung nicht besonders empfehlen, zum Teil, weil ich kein großer Fan der boolTypensemantik bin [IMHO sollte der Typ angegeben haben, dass sich ein boolWert, für den ein anderer Wert als 0 oder 1 gespeichert ist, beim Lesen möglicherweise so verhält es enthält einen nicht spezifizierten (nicht unbedingt konsistenten) ganzzahligen Wert; Wenn ein Programm versucht, einen ganzzahligen Wert zu speichern, von dem nicht bekannt ist, dass er 0 oder 1 ist, sollte er !!ihn zuerst verwenden.

Assemblersprache

NOT eax

Siehe https://www.tutorialspoint.com/assembly_programming/assembly_logical_instructions.htm

Ich gehe davon aus, dass Sie keine Sprache wählen werden, die nur darauf basiert :-) Auf jeden Fall können Sie dies in C ++ mit so etwas wie:

inline void makenot(bool &b) { b = !b; }

Siehe das folgende vollständige Programm zum Beispiel:

#include <iostream>

inline void makenot(bool &b) { b = !b; }

inline void outBool(bool b) { std::cout << (b ? "true" : "false") << '\n'; }

int main() {
    bool this_dataSource_trackedObject_currentValue_booleanFlag = false;
    outBool(this_dataSource_trackedObject_currentValue_booleanFlag);

    makenot(this_dataSource_trackedObject_currentValue_booleanFlag);
    outBool(this_dataSource_trackedObject_currentValue_booleanFlag);

    makenot(this_dataSource_trackedObject_currentValue_booleanFlag);
    outBool(this_dataSource_trackedObject_currentValue_booleanFlag);
}

Dies gibt wie erwartet aus:

false
true
false

PostScript ist eine verkettete , stapelorientierte Sprache wie Forth und hat einen unären Umschalter, nicht . Der Operator not schaltet den Wert oben auf dem Stapel um. Beispielsweise,

true    % push true onto the stack
not     % invert the top of stack
        % the top of stack is now false

Weitere Informationen finden Sie im PostScript-Referenzhandbuch (pdf) . 458.

Visual Basic.Net unterstützt dies über eine Erweiterungsmethode.

Definieren Sie die Erweiterungsmethode folgendermaßen:

<Extension>
Public Sub Flip(ByRef someBool As Boolean)
    someBool = Not someBool
End Sub

Und dann nenne es so:

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

Ihr ursprüngliches Beispiel würde also ungefähr so ​​aussehen:

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

In Rust können Sie Ihr eigenes Merkmal erstellen, um die Typen zu erweitern, die das NotMerkmal implementieren :

use std::ops::Not;
use std::mem::replace;

trait Flip {
    fn flip(&mut self);
}

impl<T> Flip for T
where
    T: Not<Output = T> + Default,
{
    fn flip(&mut self) {
        *self = replace(self, Default::default()).not();
    }
}

#[test]
fn it_works() {
    let mut b = true;
    b.flip();

    assert_eq!(b, false);
}

Sie können auch ^= truewie vorgeschlagen verwenden, und im Fall von Rust gibt es kein mögliches Problem, da dies falsekeine "getarnte" Ganzzahl wie in C oder C ++ ist:

fn main() {
    let mut b = true;
    b ^= true;
    assert_eq!(b, false);

    let mut b = false;
    b ^= true;
    assert_eq!(b, true);
}

In Python

Python unterstützt solche Funktionen, wenn die Variable mit dem Operator den Bool-Typ (True oder False) hat exclusive or (^=):

a = False
a ^= True
print(a)  # --> True
a ^= True
print(a)  # --> False

In C # :

boolean.variable.down.here ^= true;

Der boolesche ^ -Operator ist XOR, und XORing mit true ist dasselbe wie Invertieren.