Есть ли в каком-либо языке унарный логический оператор переключения?

Так что это скорее теоретический вопрос. C ++ и языки (в), непосредственно основанные на нем (Java, C #, PHP), имеют операторы быстрого доступа для присвоения результата большинства бинарных операторов первому операнду, например

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

но когда я хочу переключить логическое выражение, я всегда пишу что-то вроде

a = !a;

что раздражает, когда aэто длинное выражение вроде.

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

(да, я знаю Закон Деметры).

Поэтому мне было интересно, есть ли какой-нибудь язык с унарным логическим оператором переключения , который позволил бы мне сокращать, a = !aне повторяя выражение a, например

!=a;  
// or
a!!;

Предположим, что у нашего языка есть правильный логический тип (например, boolв C ++), и он aотносится к этому типу (поэтому нет стиля C int a = TRUE).

Если вы можете найти документированный источник, мне также было бы интересно узнать, рассматривали ли, например, разработчики C ++ возможность добавления такого оператора, когда он boolстал встроенным типом, и если да, то почему они отказались от него.

(Примечание: я знаю, что некоторые люди считают, что присваивание не следует использовать =и что операторы не являются полезными , ++а +=являются недостатками дизайна; давайте просто предположим, что я доволен ими, и сосредоточимся на том, почему они не распространяются на bools).

Этот вопрос действительно интересен с чисто теоретической точки зрения. Не говоря уже о том, будет ли полезен унарный, мутирующий логический оператор переключения , или почему многие языки предпочли его не предоставлять, я рискнул проверить, существует ли он на самом деле.

TL; DR, очевидно, нет, но Swift позволяет вам реализовать его. Если вы хотите только увидеть, как это делается, прокрутите этот ответ до конца.

После (быстрого) поиска функций различных языков я с уверенностью могу сказать, что ни один язык не реализовал этот оператор как операцию строгого изменения на месте (исправьте меня, если вы ее найдете). Итак, следующим шагом будет посмотреть, есть ли языки, которые позволят вам создать такой язык. Для этого потребуются две вещи:

1. возможность реализовать (унарные) операторы с функциями
2. позволяя указанным функциям иметь аргументы, передаваемые по ссылке (чтобы они могли напрямую изменять свои аргументы)

Многие языки будут немедленно исключены за то, что не поддерживают одно или оба этих требования. Например, Java не допускает перегрузки операторов (или пользовательских операторов), и, кроме того, все примитивные типы передаются по значению. Go вообще не поддерживает перегрузку оператора (кроме как путем взлома ). Rust допускает перегрузку операторов только для пользовательских типов. Вы могли бы почти достичь этого в Scala , который позволяет вам использовать очень креативно названные функции, а также опускать скобки, но, к сожалению, здесь нет передачи по ссылке. Фортран очень близок в том, что он позволяет использовать пользовательские операторы, но специально запрещает им иметь inout параметры (которые разрешены в обычных функциях и подпрограммах).

Однако есть по крайней мере один язык, на котором отмечены все необходимые поля: Swift . Хотя некоторые люди связались с предстоящей функцией- членом .toggle () , вы также можете написать свой собственный оператор, который действительно поддерживает inout- аргументы. И вот:

prefix operator ^

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

var foo = true
print(foo)
// true

^foo

print(foo)
// false

Переключение логического бита

... это позволило бы мне сократить, a = !a не повторяя выражение дляa ...

Этот подход на самом деле не является чистым оператором «изменяющегося переворота», но он удовлетворяет указанным выше критериям; правая часть выражения не включает саму переменную.

Любой язык с логическим назначением XOR (например, ^=) позволит перевернуть текущее значение переменной, скажем a, с помощью назначения XOR true:

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

Как указано @cmaster в комментариях ниже, выше предполагается, что aэто тип bool, а не, например, целое число или указатель. Если aна самом деле это что-то еще (например, что-то, не boolоцениваемое до «правдивого» или «ложного» значения, с битовым представлением, которое не является 0b1или 0b0, соответственно), вышеуказанное не выполняется.

В качестве конкретного примера, Java - это язык, в котором он четко определен и не подлежит никаким преобразованиям без вывода сообщений. Цитата из комментария @Boann снизу:

В Java ^и ^=имеют явно определенное поведение для логических и целых чисел ( 15.22.2. Логические операторы Boolean &, ^и| ), где либо обе стороны оператора должны быть логическими, либо обе стороны должны быть целыми числами. Между этими типами нет тихого преобразования. Таким образом, если aон объявлен как целое число, он не будет работать тихо , а скорее выдаст ошибку компиляции. Так a ^= true;безопасно и хорошо определены в Java.

Swift: toggle()

Начиная с Swift 4.2, следующее предложение по развитию было принято и реализовано:

• SE-0199: Добавление переключателя в Bool

Это добавляет встроенную toggle()функцию к Boolтипу в Swift.

toggle()

Переключает значение логической переменной.

Декларация

mutating func toggle()

Обсуждение

Используйте этот метод для переключения логического значения с trueна falseили с falseна true.

var bools = [true, false]

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

Сам по себе это не оператор, но он позволяет использовать родной язык для логического переключения.

В C ++ можно совершить кардинальный грех переопределения значений операторов. Имея это в виду и немного ADL, все, что нам нужно сделать, чтобы развязать хаос в нашей пользовательской базе, это следующее:

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

ожидаемый результат:

6
0
1
0
1

Пока мы включаем ассемблер ...

Четвертый

INVERT для побитового дополнения.

0= для логического (истина / ложь) дополнения.

Уменьшение C99 boolбудет иметь желаемый эффект, так же как будет увеличивать или уменьшать bitтипы, поддерживаемые в некоторых диалектах крошечных микроконтроллеров (которые из того, что я наблюдал, рассматривают биты как однобитовые битовые поля, поэтому все четные числа усекаются до 0 и все нечетные числа до 1). Я бы не особо рекомендовал такое использование, отчасти потому, что я не большой поклонник boolсемантики типа [IMHO, тип должен был указывать, что a, boolв котором хранится любое значение, отличное от 0 или 1, может вести себя при чтении как если бы он содержит неопределенное (не обязательно непротиворечивое) целочисленное значение; если программа пытается сохранить целочисленное значение, которое, как известно, не равно 0 или 1, она должна !!сначала использовать его].

язык ассемблера

NOT eax

См. Https://www.tutorialspoint.com/assembly_programming/assembly_logical_instructions.htm

Я предполагаю, что вы не собираетесь выбирать язык, основываясь исключительно на этом :-) В любом случае вы можете сделать это на C ++ примерно так:

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

См., Например, следующую полную программу:

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

Это выводит, как и ожидалось:

false
true
false

PostScript , будучи конкатенативным , стек-ориентированный язык , как Forth, имеет одноместную тумблер, не . Оператор not переключает значение на вершине стека. Например,

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

См. Справочное руководство по языку PostScript (pdf) , стр. 458.

Visual Basic.Net поддерживает это с помощью метода расширения.

Определите метод расширения следующим образом:

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

А потом назовите это так:

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

Итак, ваш исходный пример будет выглядеть примерно так:

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

В Rust вы можете создать свой собственный трейт для расширения типов, реализующих 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);
}

Вы также можете использовать, ^= trueкак было предложено, и в случае Rust нет никаких проблем с этим, потому что falseэто не "замаскированное" целое число, как в C или C ++:

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

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

В Python

Python поддерживает такую ​​функциональность, если переменная имеет тип bool (True или False) с exclusive or (^=)оператором:

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

В C # :

boolean.variable.down.here ^= true;

Логический оператор ^ - это XOR, а операция XOR с истиной аналогична инвертированию.