Czy jakikolwiek język ma jednoargumentowy operator przełączania logicznego?

Jest to więc bardziej teoretyczne pytanie. C ++ i języki (in) bezpośrednio na nim oparte (Java, C #, PHP) mają operatory skrótów do przypisywania wyniku większości operatorów binarnych do pierwszego operandu, takie jak

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

ale kiedy chcę zmienić wyrażenie boolowskie, zawsze piszę coś takiego

a = !a;

co staje się irytujące, gdy ajest to długie wyrażenie.

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

(tak, prawo Demeter, wiem).

Zastanawiałem się więc, czy istnieje język z jednoargumentowym operatorem przełączania typu boolean , który pozwoliłby mi skrócić a = !abez powtarzania wyrażenia a, na przykład

!=a;  
// or
a!!;

Załóżmy, że nasz język ma odpowiedni typ boolowski (jak boolw C ++) i to ajest tego typu (więc nie ma stylu C int a = TRUE).

Jeśli możesz znaleźć udokumentowane źródło, chciałbym się również dowiedzieć, czy np. Projektanci C ++ rozważali dodanie takiego operatora, kiedy boolstał się typem wbudowanym, a jeśli tak, to dlaczego zdecydowali się na nie.

(Uwaga: Wiem, że niektórzy ludzie są zdania, że zadanie nie należy używać =i że ++i +=nie są użyteczne, ale operatorzy wady projektowe; niech tylko zakładać, że jestem zadowolony z nich i skupić się dlaczego oni nie rozciąga się bools).

To pytanie jest rzeczywiście interesujące z czysto teoretycznego punktu widzenia. Pomijając, czy jednoargumentowy, mutujący operator przełączający byłby przydatny, czy też dlaczego wiele języków zdecydowało się go nie udostępniać, zaryzykowałem poszukiwanie, czy rzeczywiście istnieje.

TL; DR najwyraźniej nie, ale Swift pozwala na wdrożenie jednego. Jeśli chcesz tylko zobaczyć, jak to się robi, możesz przewinąć do końca tej odpowiedzi.

Po (szybkim) wyszukiwaniu funkcji w różnych językach mogę śmiało powiedzieć, że żaden język nie zaimplementował tego operatora jako ścisłej operacji mutacji w miejscu (popraw mnie, jeśli go znajdziesz). Więc następną rzeczą byłoby sprawdzenie, czy istnieją języki, w których można go zbudować. Wymagałoby to dwóch rzeczy:

1. możliwość implementacji (jednoargumentowych) operatorów z funkcjami
2. zezwalanie tym funkcjom na posiadanie argumentów typu pass-by-reference (aby mogły bezpośrednio mutować swoje argumenty)

Wiele języków zostanie natychmiast wykluczonych ze względu na brak obsługi jednego lub obu tych wymagań. Java dla one nie zezwala na przeciążanie operatorów (lub operatorów niestandardowych), a ponadto wszystkie typy pierwotne są przekazywane przez wartość. Go w ogóle nie obsługuje przeciążania operatorów (z wyjątkiem hacków ). Rust zezwala na przeciążanie operatorów tylko dla typów niestandardowych. Możesz to prawie osiągnąć w Scali , która pozwala ci używać bardzo twórczo nazwanych funkcji, a także pomijać nawiasy, ale niestety nie ma żadnego odniesienia do przekazywania. języka Fortran jest bardzo blisko, ponieważ pozwala na niestandardowych operatorów, ale wyraźnie zabrania im inout parametry (które są dozwolone w normalnych funkcjach i podprogramach).

Jest jednak co najmniej jeden język, który spełnia wszystkie niezbędne warunki: Swift . Chociaż niektórzy ludzie utworzyli linki do nadchodzącej funkcji składowej .toggle () , możesz także napisać własny operator, który rzeczywiście obsługuje argumenty inout . Oto i oto:

prefix operator ^

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

var foo = true
print(foo)
// true

^foo

print(foo)
// false

Przełączanie bitu boolowskiego

... to pozwoliłoby mi skrócić a = !a bez powtarzania wyrażenia dlaa ...

To podejście nie jest tak naprawdę czystym operatorem „mutującego odwrócenia”, ale spełnia powyższe kryteria; prawa strona wyrażenia nie obejmuje samej zmiennej.

Każdy język z logicznym przypisaniem XOR (np. ^=) Pozwoliłby na odwrócenie bieżącej wartości zmiennej, powiedzmy a, za pomocą przypisania XOR do true:

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

Jak zauważył @cmaster w komentarzach poniżej, powyższe zakłada, że ajest to typ bool, a nie np. Liczba całkowita lub wskaźnik. Jeśli aw rzeczywistości jest czymś innym (np. boolCzymś nieoceniającym do „prawdziwej” lub „fałszywej” wartości, z reprezentacją bitową, która nie jest 0b1lub 0b0, odpowiednio), powyższe nie obowiązuje.

Na przykład Java jest językiem, w którym jest dobrze zdefiniowany i nie podlega żadnym cichym konwersjom. Cytując komentarz @ Boann z dołu:

W Java ^i ^=są wyraźnie określone dla zachowania logicznych i liczb ( 15.22.2. Logicznych operatorów logicznych &, ^i| ), przy czym zarówno obie boczne części operator musi mieć wartości logiczne lub obie strony muszą być liczbami całkowitymi. Nie ma cichej konwersji między tymi typami. Więc nie będzie cicho działać nieprawidłowo, jeśli azostanie zadeklarowana jako liczba całkowita, ale raczej spowoduje błąd kompilacji. Więc a ^= true;jest bezpieczny i dobrze zdefiniowany w Javie.

Szybki: toggle()

W wersji Swift 4.2 przyjęto i wdrożono następującą propozycję ewolucji:

• SE-0199: Dodawanie przełącznika do Bool

To dodaje natywną toggle()funkcję do Booltypu w Swift.

toggle()

Przełącza wartość zmiennej boolowskiej.

Deklaracja

mutating func toggle()

Dyskusja

Użyj tej metody, aby przełączyć wartość logiczną od truedo falselub od falsedo true.

var bools = [true, false]

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

Nie jest to operator sam w sobie, ale pozwala na natywne podejście języka do przełączania wartości logicznych.

W C ++ można popełnić kardynalny grzech przedefiniowania znaczenia operatorów. Mając to na uwadze i trochę ADL, wszystko, co musimy zrobić, aby uwolnić chaos w naszej bazie użytkowników, to:

#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;
}

oczekiwany wynik:

6
0
1
0
1

Jeśli włączymy język asemblera ...

NAPRZÓD

INVERT do bitowego uzupełnienia.

0= dla logicznego (prawda / fałsz) uzupełnienia.

Zmniejszanie C99 bool przyniesie pożądany efekt, podobnie jak zwiększenie lub zmniejszenie bittypów obsługiwanych w niektórych dialektach z małymi mikrokontrolerami (które z tego, co zaobserwowałem, traktują bity jako pola bitowe o szerokości jednego bitu, więc wszystkie liczby parzyste są obcinane do 0 i wszystkie liczby nieparzyste do 1). Nie polecałbym szczególnie takiego użycia, po części dlatego, że nie jestem wielkim fanem boolsemantyki typu [IMHO, typ powinien był określićże a booldo którego zapisana jest wartość inna niż 0 lub 1 może zachowywać się po przeczytaniu zawiera nieokreśloną (niekoniecznie spójną) wartość całkowitą; jeśli program próbuje zapisać wartość całkowitą, o której nie wiadomo, czy jest równa 0 lub 1, powinien !!najpierw użyć na niej].

język programowania

NOT eax

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

Zakładam, że nie będziesz wybierać języka opartego wyłącznie na tym :-) W każdym razie możesz to zrobić w C ++ za pomocą czegoś takiego:

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

Zobacz na przykład następujący kompletny program:

#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);
}

To daje, zgodnie z oczekiwaniami:

false
true
false

PostScript , będący konkatenatywnym , zorientowanym na stos językiem, takim jak Forth, ma jednoargumentowy przełącznik, a nie . nie operator przełącza wartość na górze stosu. Na przykład,

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

Patrz Poradnik języka PostScript (pdf) , str. 458.

Visual Basic.Net obsługuje to poprzez metodę rozszerzenia.

Zdefiniuj metodę rozszerzenia w następujący sposób:

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

A potem nazwij to tak:

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

Twój oryginalny przykład wyglądałby mniej więcej tak:

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

W Rust możesz stworzyć własną cechę, aby rozszerzyć typy, które ją implementują Not:

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);
}

Możesz również użyć ^= truezgodnie z sugestią, aw przypadku Rusta nie ma problemu, aby to zrobić, ponieważ falsenie jest to „zamaskowana” liczba całkowita, jak w C lub C ++:

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

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

W Pythonie

Python obsługuje taką funkcjonalność, jeśli zmienna ma typ bool (czyli True lub False) z exclusive or (^=)operatorem:

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

W C # :

boolean.variable.down.here ^= true;

Operatorem boolowskim ^ jest XOR, a XOR z wartością true jest tym samym, co odwracanie.