Une langue a-t-elle un opérateur de bascule booléen unaire?

C'est donc plus une question théorique. C ++ et les langages (in) directement basés sur celui-ci (Java, C #, PHP) ont des opérateurs de raccourcis pour affecter le résultat de la plupart des opérateurs binaires au premier opérande, comme

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

mais quand je veux basculer une expression booléenne, je me surprends toujours à écrire quelque chose comme

a = !a;

ce qui devient ennuyeux quand aest une longue expression comme.

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

(ouais, la loi de Demeter, je sais).

Je me demandais donc s'il existe un langage avec un opérateur de bascule booléen unaire qui me permettrait d'abréger a = !asans répéter l'expression pour a, par exemple

!=a;  
// or
a!!;

Supposons que notre langage ait un type booléen approprié (comme boolen C ++) et qu'il asoit de ce type (donc pas de style C int a = TRUE).

Si vous pouvez trouver une source documentée, je serais également intéressé de savoir si, par exemple, les concepteurs C ++ ont envisagé d'ajouter un opérateur comme celui-ci lorsqu'il boolest devenu un type intégré et si oui, pourquoi ils ont décidé de ne pas le faire.

(Note: Je sais que certaines personnes sont d'avis que la cession ne devrait pas utiliser =et que ++et +=ne sont pas opérateurs utiles , mais des défauts de conception, Assumons que je suis heureux avec eux et se concentrer sur la raison pour laquelle ils ne seraient pas étendre à bools).

Cette question est en effet intéressante d'un point de vue purement théorique. Mettant de côté la question de savoir si un opérateur de bascule booléen unaire et mutant serait utile, ou pourquoi de nombreuses langues ont choisi de ne pas en fournir, je me suis aventuré dans une quête pour voir s'il existe ou non.

TL; DR apparemment non, mais Swift vous permet d'en implémenter un. Si vous souhaitez seulement voir comment cela se fait, vous pouvez faire défiler vers le bas de cette réponse.

Après une recherche (rapide) sur les fonctionnalités de différentes langues, je me sentirais en sécurité pour dire qu'aucune langue n'a implémenté cet opérateur en tant qu'opération sur place à mutation stricte (corrigez-moi si vous en trouvez une). La prochaine chose à faire serait donc de voir s'il existe des langages qui vous permettent d'en créer un. Cela nécessiterait deux choses:

1. être capable d'implémenter des opérateurs (unaires) avec des fonctions
2. permettre auxdites fonctions d'avoir des arguments de passage par référence (afin qu'elles puissent muter leurs arguments directement)

De nombreuses langues seront immédiatement exclues pour ne pas prendre en charge l'une ou l'autre de ces exigences ou les deux. Java for one n'autorise pas la surcharge d'opérateurs (ou d'opérateurs personnalisés) et de plus, tous les types primitifs sont passés par valeur. Go n'a aucun support pour la surcharge des opérateurs (sauf par des hacks ). Rust autorise uniquement la surcharge des opérateurs pour les types personnalisés. Vous pourriez presque y parvenir dans Scala , qui vous permet d'utiliser des fonctions nommées de manière très créative et d'omettre également les parenthèses, mais malheureusement, il n'y a pas de référence. Fortran est très proche en ce sens qu'il permet aux opérateurs personnalisés, mais leur interdit spécifiquement d'avoir des inout paramètres (qui sont autorisés dans les fonctions et sous-programmes normaux).

Il existe cependant au moins une langue qui coche toutes les cases nécessaires: Swift . Alors que certaines personnes se sont liées à la prochaine fonction membre .toggle () , vous pouvez également écrire votre propre opérateur, qui prend en effet en charge les arguments inout . Et voilà:

prefix operator ^

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

var foo = true
print(foo)
// true

^foo

print(foo)
// false

Basculer le bit booléen

... cela me permettrait d'abréger a = !a sans répéter l'expression dea ...

Cette approche n'est pas vraiment un pur opérateur de «retournement mutant», mais remplit vos critères ci-dessus; le côté droit de l'expression n'implique pas la variable elle-même.

Tout langage avec une affectation XOR booléenne (par exemple ^=) permettrait de basculer la valeur actuelle d'une variable, par exemple a, au moyen d'une affectation 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

Comme indiqué par @cmaster dans les commentaires ci-dessous, ce qui précède suppose qu'il aest de type bool, et non par exemple un entier ou un pointeur. S'il as'agit en fait de quelque chose d'autre (par exemple quelque chose qui booln'évalue pas à une valeur "véridique" ou "falsifiée", avec une représentation binaire qui n'est pas 0b1ou 0b0, respectivement), ce qui précède ne tient pas.

Pour un exemple concret, Java est un langage dans lequel il est bien défini et ne fait l'objet d'aucune conversion silencieuse. Citant le commentaire de @ Boann ci-dessous:

En Java, ^et ^=ont un comportement explicitement défini pour booléens et pour les entiers ( 15.22.2. Opérateurs logiques booléens &, ^et| ), où soit les deux côtés de l'opérateur doivent être booléens, ou les deux parties doivent être des nombres entiers. Il n'y a pas de conversion silencieuse entre ces types. Donc, il ne fonctionnera pas silencieusement si aest déclaré sous forme d'entier, mais donnera plutôt une erreur de compilation. C'est donc a ^= true;sûr et bien défini en Java.

Rapide: toggle()

Depuis Swift 4.2, la proposition d'évolution suivante a été acceptée et mise en œuvre:

• SE-0199: Ajout de bascule à Bool

Cela ajoute une toggle()fonction native au Booltype dans Swift.

toggle()

Active / désactive la valeur de la variable booléenne.

Déclaration

mutating func toggle()

Discussion

Utilisez cette méthode pour faire basculer une valeur booléenne de trueà falseou de falseà true.

var bools = [true, false]

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

Ce n'est pas un opérateur en soi, mais permet une approche native du langage pour le basculement booléen.

En C ++, il est possible de commettre le péché cardinal de redéfinir le sens des opérateurs. Dans cet esprit, et un peu d'ADL, tout ce que nous devons faire pour déchaîner le chaos sur notre base d'utilisateurs est la suivante:

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

production attendue:

6
0
1
0
1

Tant que nous incluons le langage d'assemblage ...

FORTH

INVERT pour un complément au niveau du bit.

0= pour un complément logique (vrai / faux).

La décrémentation d'un C99 boolaura l'effet désiré, tout comme l'incrémentation ou la décrémentation dubit types pris en charge dans certains dialectes de minuscules microcontrôleurs (qui, d'après ce que j'ai observé, traitent les bits comme des champs de bits larges d'un seul bit, de sorte que tous les nombres pairs sont tronqués à 0 et tous nombres impairs à 1). Je ne recommanderais pas particulièrement une telle utilisation, en partie parce que je ne suis pas un grand fan de la boolsémantique de type [À mon humble avis, le type aurait dû spécifier que a boolauquel toute valeur autre que 0 ou 1 est stockée peut se comporter lorsqu'il est lu comme si il contient une valeur entière non spécifiée (pas nécessairement cohérente); si un programme essaie de stocker une valeur entière qui n'est pas connue pour être 0 ou 1, il doit l'utiliser !!en premier].

Langue d'assemblage

NOT eax

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

Je suppose que vous n'allez pas choisir un langage basé uniquement sur ceci :-) Dans tous les cas, vous pouvez le faire en C ++ avec quelque chose comme:

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

Voir le programme complet suivant par exemple:

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

Cela produit, comme prévu:

false
true
false

PostScript , étant un concaténative , orienté pile langage comme Forth, a une bascule unaire, non . L' opérateur not bascule la valeur en haut de la pile. Par exemple,

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

Voir le Manuel de référence du langage PostScript (pdf) , p. 458.

Visual Basic.Net prend en charge cela via une méthode d'extension.

Définissez la méthode d'extension comme ceci:

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

Et puis appelez-le comme ceci:

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

Ainsi, votre exemple original ressemblerait à quelque chose comme:

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

Dans Rust, vous pouvez créer votre propre trait pour étendre les types qui implémentent le Nottrait:

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

Vous pouvez également utiliser ^= truecomme suggéré, et dans le cas de Rust, il n'y a pas de problème possible car ce falsen'est pas un entier "déguisé" comme en C ou 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 prend en charge cette fonctionnalité, si la variable a un type booléen (qui est True ou False) avec l' exclusive or (^=)opérateur:

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

En C # :

boolean.variable.down.here ^= true;

L'opérateur booléen ^ est XOR et XORing avec true est identique à l'inversion.