¿Algún idioma tiene un operador de alternancia booleano unario?

Entonces esta es más una pregunta teórica. C ++ y los lenguajes (in) directamente basados ​​en él (Java, C #, PHP) tienen operadores de acceso directo para asignar el resultado de la mayoría de los operadores binarios al primer operando, como

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

pero cuando quiero alternar una expresión booleana siempre me encuentro escribiendo algo como

a = !a;

lo que se vuelve molesto cuando aes una expresión larga como.

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

(Sí, la Ley de Demeter, lo sé).

Así que me preguntaba, ¿hay algún lenguaje con un operador de alternancia booleano unario que me permita abreviar a = !asin repetir la expresión para a, por ejemplo

!=a;  
// or
a!!;

Supongamos que nuestro lenguaje tiene un tipo booleano adecuado (como boolen C ++) y que aes de ese tipo (por lo que no tiene estilo C int a = TRUE).

Si puede encontrar una fuente documentada, también me interesaría saber si, por ejemplo, los diseñadores de C ++ han considerado agregar un operador como ese cuando bool convirtió en un tipo incorporado y, de ser así, por qué decidieron no hacerlo.

(Nota: Sé que algunas personas son de la opinión de que la asignación no se debe usar =y que ++y +=no son útiles, pero los operadores de defectos de diseño, vamos a asumir que estoy feliz con ellos y se centran en por qué no se extenderían a Bools).

Esta pregunta es realmente interesante desde un punto de vista puramente teórico. Dejando a un lado si sería útil o no un operador de palanca booleano mutante o unario, o por qué muchos idiomas han optado por no proporcionar uno, me aventuré en una búsqueda para ver si realmente existe o no.

TL; DR aparentemente no, pero Swift le permite implementar uno. Si solo desea ver cómo se hace, puede desplazarse hasta el final de esta respuesta.

Después de una búsqueda (rápida) de las características de varios idiomas, me sentiría seguro al decir que ningún idioma ha implementado este operador como una operación in situ mutante estricta (corríjame si encuentra uno). Entonces, lo siguiente sería ver si hay idiomas que le permitan construir uno. Lo que esto requeriría es dos cosas:

1. ser capaz de implementar operadores (unarios) con funciones
2. permitiendo que dichas funciones tengan argumentos de paso por referencia (para que puedan mutar sus argumentos directamente)

Muchos idiomas se descartarán inmediatamente por no admitir ninguno de estos requisitos o ambos. Java for one no permite la sobrecarga de operadores (u operadores personalizados) y, además, todos los tipos primitivos se pasan por valor. Go no tiene soporte para la sobrecarga del operador (excepto por hacks ) en absoluto. Rust solo permite la sobrecarga del operador para tipos personalizados. Casi podría lograr esto en Scala , que le permite usar funciones con nombres muy creativos y también omitir paréntesis, pero lamentablemente no hay paso por referencia. Fortran se acerca mucho, ya que permite operadores personalizados, pero específicamente les prohíbe tener inout parámetros (que están permitidos en funciones normales y subrutinas).

Sin embargo, hay al menos un idioma que cumple todos los requisitos: Swift . Si bien algunas personas se han vinculado a la próxima función miembro .toggle () , también puede escribir su propio operador, que de hecho admite argumentos inout . Lo y he aquí:

prefix operator ^

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

var foo = true
print(foo)
// true

^foo

print(foo)
// false

Alternar el bit booleano

... eso me permitiría abreviar a = !a sin repetir la expresión paraa ...

Este enfoque no es realmente un operador puro de "cambio mutante", pero cumple con los criterios anteriores; el lado derecho de la expresión no involucra la variable en sí.

Cualquier lenguaje con una asignación XOR booleana (por ejemplo ^=) permitiría cambiar el valor actual de una variable, por ejemplo a, mediante la asignación XOR a true:

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

Como señaló @cmaster en los comentarios a continuación, lo anterior supone que aes de tipo booly no, por ejemplo, un número entero o un puntero. Si, ade hecho, es otra cosa (por ejemplo, algo que no se boolevalúa como un valor "verdadero" o "falso", con una representación de bits que no es 0b1o 0b0, respectivamente), lo anterior no se cumple.

Para un ejemplo concreto, Java es un lenguaje donde está bien definido y no está sujeto a ninguna conversión silenciosa. Citando el comentario de @ Boann a continuación:

En Java, ^y ^=tienen un comportamiento explícitamente definido para booleanos y enteros ( 15.22.2. Los operadores lógicos booleanos &, ^y| ), donde cualquiera de los dos lados del operador deben ser booleanos, o en ambos lados deben ser enteros. No hay conversión silenciosa entre esos tipos. Por lo tanto, no funcionará silenciosamente si ase declara como un entero, sino que dará un error de compilación. Por a ^= true;lo tanto, es seguro y está bien definido en Java.

Rápido: toggle()

A partir de Swift 4.2, la siguiente propuesta de evolución ha sido aceptada e implementada:

• SE-0199: Agregar alternar a Bool

Esto agrega una toggle()función nativa alBool tipo en Swift.

toggle()

Alterna el valor de la variable booleana.

Declaración

mutating func toggle()

Discusión

Utilice este método para cambiar un valor booleano truea falseo desde falsea true.

var bools = [true, false]

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

Este no es un operador, per se, pero permite un enfoque nativo de lenguaje para alternar booleano.

En C ++ es posible cometer el pecado cardinal de redefinir el significado de los operadores. Con esto en mente, y un poco de ADL, todo lo que tenemos que hacer para desatar el caos en nuestra base de usuarios es esto:

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

Rendimiento esperado:

6
0
1
0
1

Siempre que incluyamos lenguaje ensamblador ...

ADELANTE

INVERT para un complemento bit a bit.

0= para un complemento lógico (verdadero / falso).

Disminuir un C99 booltendrá el efecto deseado, al igual que aumentar o disminuir los bittipos admitidos en algunos dialectos de microcontroladores pequeños (que por lo que he observado tratan los bits como campos de bits anchos de un solo bit, por lo que todos los números pares se truncan a 0 y todos números impares a 1). En particular, no recomendaría tal uso, en parte porque no soy un gran admirador de la boolsemántica de tipos [En mi humilde opinión, el tipo debería haber especificado que un boolcomportamiento al que se almacena cualquier valor distinto de 0 o 1 puede comportarse cuando se lee como si tiene un valor entero no especificado (no necesariamente consistente); si un programa está tratando de almacenar un valor entero que no se sabe que es 0 o 1, debería usarlo !!primero].

Lenguaje ensamblador

NOT eax

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

Supongo que no va a elegir un lenguaje basado únicamente en esto :-) En cualquier caso, puede hacer esto en C ++ con algo como:

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

Vea el siguiente programa completo, por ejemplo:

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

Esto produce, como se esperaba:

false
true
false

PostScript , al ser una concatenación , orientado a pila idioma como el Forth, tiene un conmutador unario, no . El operador no alterna el valor en la parte superior de la pila. Por ejemplo,

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

Consulte el Manual de referencia del lenguaje PostScript (pdf) , pág. 458.

Visual Basic.Net admite esto mediante un método de extensión.

Defina el método de extensión así:

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

Y luego llámalo así:

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

Entonces, su ejemplo original se vería así:

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

En Rust, puede crear su propio rasgo para extender los tipos que implementan el Notrasgo:

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

También puedes usar ^= true como se sugiere, y en el caso de Rust, no hay problema posible para hacer esto porque falseno es un número entero "disfrazado" como en C o C ++:

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

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

En python

Python admite dicha funcionalidad, si la variable tiene tipo bool (que es Verdadero o Falso) con el exclusive or (^=)operador:

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

En C # :

boolean.variable.down.here ^= true;

El operador booleano ^ es XOR, y XORing con verdadero es lo mismo que invertir.