Có ngôn ngữ nào có toán tử chuyển đổi boolean unary không?

Vì vậy, đây là nhiều hơn một câu hỏi lý thuyết. C ++ và các ngôn ngữ (in) trực tiếp dựa trên nó (Java, C #, PHP) có các toán tử phím tắt để gán kết quả của hầu hết các toán tử nhị phân cho toán hạng đầu tiên, chẳng hạn như

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

nhưng khi tôi muốn chuyển đổi một biểu thức boolean, tôi luôn thấy mình viết một cái gì đó như

a = !a;

Điều này gây khó chịu khi amột biểu hiện dài như thế nào.

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

(vâng, Luật của Demeter, tôi biết).

Vì vậy, tôi đã tự hỏi, có ngôn ngữ nào với toán tử chuyển đổi boolean unary sẽ cho phép tôi viết tắt a = !amà không lặp lại biểu thức cho a, ví dụ

!=a;  
// or
a!!;

Giả sử rằng ngôn ngữ của chúng ta có loại boolean thích hợp (như booltrong C ++) và đó alà loại đó (vì vậy không có kiểu C int a = TRUE).

Nếu bạn có thể tìm thấy một nguồn tài liệu, tôi cũng muốn tìm hiểu xem, ví dụ như các nhà thiết kế C ++ đã xem xét việc thêm một toán tử như thế khi booltrở thành một loại tích hợp và nếu vậy, tại sao họ lại quyết định chống lại nó.

(Lưu ý: Tôi biết rằng một số người có quan điểm rằng việc chuyển nhượng không nên sử dụng =và điều đó ++và +=không phải là các nhà khai thác hữu ích nhưng lỗi trong thiết kế; chúng ta hãy chỉ giả sử tôi đang hạnh phúc với họ và tập trung vào lý do tại sao họ sẽ không mở rộng đến bools).

Câu hỏi này thực sự thú vị từ quan điểm lý thuyết thuần túy. Đặt sang một bên có hay không một toán tử chuyển đổi boolean biến đổi có hữu ích hay không, hoặc tại sao nhiều ngôn ngữ đã chọn không cung cấp một ngôn ngữ, tôi mạo hiểm tìm kiếm xem liệu nó có thực sự tồn tại hay không.

TL; DR rõ ràng là không, nhưng Swift cho phép bạn thực hiện một. Nếu bạn chỉ muốn xem nó được thực hiện như thế nào, bạn có thể cuộn xuống cuối câu trả lời này.

Sau khi tìm kiếm (nhanh chóng) các tính năng của các ngôn ngữ khác nhau, tôi cảm thấy an toàn khi nói rằng không có ngôn ngữ nào triển khai toán tử này như một hoạt động đột biến tại chỗ nghiêm ngặt (hãy sửa tôi nếu bạn tìm thấy một ngôn ngữ). Vì vậy, điều tiếp theo sẽ là xem có ngôn ngữ nào cho phép bạn xây dựng một ngôn ngữ không. Điều này đòi hỏi hai điều:

1. có thể thực hiện các toán tử (đơn nguyên) với các hàm
2. cho phép các hàm nói có các đối số tham chiếu qua (để chúng có thể thay đổi trực tiếp các đối số của chúng)

Nhiều ngôn ngữ sẽ ngay lập tức bị loại trừ vì không hỗ trợ một trong hai hoặc cả hai yêu cầu này. Java cho một người không cho phép quá tải toán tử (hoặc toán tử tùy chỉnh) và ngoài ra, tất cả các kiểu nguyên thủy được truyền theo giá trị. Go không có hỗ trợ cho quá tải toán tử (ngoại trừ hack ). Rust chỉ cho phép người vận hành quá tải cho các loại tùy chỉnh. Bạn gần như có thể đạt được điều này trong Scala , cho phép bạn sử dụng các hàm được đặt tên rất sáng tạo và cũng bỏ qua dấu ngoặc đơn, nhưng thật đáng buồn là không có tham chiếu qua. Fortran được rất gần ở chỗ nó cho phép các nhà khai thác tùy chỉnh, nhưng đặc biệt cấm họ khỏi phải inout tham số (được phép trong các hàm và chương trình con bình thường).

Tuy nhiên, có ít nhất một ngôn ngữ đánh dấu vào tất cả các ô cần thiết: Swift . Trong khi một số người đã liên quan đến sắp tới .toggle () chức năng thành viên, bạn cũng có thể viết điều hành của riêng mình, mà thực sự hỗ trợ inout đối số. Lo và kìa:

prefix operator ^

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

var foo = true
print(foo)
// true

^foo

print(foo)
// false

Vượt qua bit boolean

... Điều đó sẽ cho phép tôi viết tắt a = !a mà không cần lặp lại biểu thức choa ...

Cách tiếp cận này không thực sự là một toán tử "đột biến lật" thuần túy, nhưng thực hiện đầy đủ các tiêu chí của bạn ở trên; phía bên phải của biểu thức không liên quan đến chính biến.

Bất kỳ ngôn ngữ nào có gán XOR boolean (ví dụ ^=) sẽ cho phép lật giá trị hiện tại của một biến a, bằng cách gán XOR cho true:

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

Như @cmaster đã chỉ ra trong các bình luận bên dưới, các giả định ở trên athuộc loại boolchứ không phải là số nguyên hoặc con trỏ. Nếu atrên thực tế là một cái gì đó khác (ví dụ như một cái gì đó không boolđánh giá thành giá trị "trung thực" hoặc "giả mạo", với một đại diện bit không tương ứng 0b1hoặc 0b0, tương ứng), thì ở trên không giữ.

Đối với một ví dụ cụ thể, Java là một ngôn ngữ mà ngôn ngữ này được xác định rõ và không chịu bất kỳ chuyển đổi im lặng nào. Trích dẫn bình luận của @ Boann từ bên dưới:

Trong Java, ^và ^=đã xác định một cách rõ ràng hành vi cho các phép toán luận và cho số nguyên ( 15.22.2. Các nhà khai thác logic Boolean &, ^và| ), nơi một trong hai cả hai bên của các nhà điều hành phải có các phép toán luận, hoặc cả hai bên phải là số nguyên. Không có chuyển đổi im lặng giữa các loại. Vì vậy, nó sẽ không âm thầm trục trặc nếu ađược khai báo là một số nguyên, mà thay vào đó, đưa ra một lỗi biên dịch. Vì vậy, a ^= true;là an toàn và được xác định rõ trong Java.

Nhanh: toggle()

Kể từ Swift 4.2, đề xuất tiến hóa sau đây đã được chấp nhận và thực hiện:

• SE-0199: Thêm chuyển đổi vào Bool

Điều này thêm một toggle()chức năng riêng cho Boolloại trong Swift.

toggle()

Chuyển giá trị của biến Boolean.

Tờ khai

mutating func toggle()

Thảo luận

Sử dụng phương pháp này để chuyển đổi giá trị Boolean từ truesang falsehoặc từ falseđến true.

var bools = [true, false]

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

Đây không phải là một toán tử, nhưng sẽ cho phép một cách tiếp cận ngôn ngữ riêng để chuyển đổi boolean.

Trong C ++, có thể cam kết Hồng y Sin xác định lại ý nghĩa của các toán tử. Với suy nghĩ này và một chút ADL, tất cả những gì chúng ta cần làm để giải phóng tình trạng hỗn loạn trên cơ sở người dùng của mình là:

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

sản lượng dự kiến:

6
0
1
0
1

Miễn là chúng tôi bao gồm ngôn ngữ lắp ráp ...

FORTH

INVERT cho một bổ sung bitwise.

0= cho một bổ sung hợp lý (đúng / sai).

Việc giảm C99 boolsẽ có hiệu ứng mong muốn, cũng như tăng hoặc giảm các bitloại được hỗ trợ trong một số phương ngữ vi điều khiển nhỏ (mà từ đó tôi đã quan sát thấy các bit là bitfield rộng một bit, vì vậy tất cả các số chẵn đều bị cắt thành 0 và tất cả số lẻ thành 1). Tôi đặc biệt không khuyến nghị sử dụng như vậy, một phần vì tôi không phải là người hâm mộ lớn về boolngữ nghĩa loại [IMHO, loại nên đã chỉ định rằng một boolgiá trị nào khác 0 hoặc 1 được lưu trữ có thể hoạt động khi đọc như thể nó giữ một giá trị nguyên không xác định (không nhất thiết nhất quán); nếu một chương trình đang cố lưu trữ một giá trị số nguyên không được biết là 0 hoặc 1, thì nó sẽ sử dụng !!nó trước tiên].

Hợp ngữ

NOT eax

Xem https://www.tutorialspoint.com/assinstall_programming/assinstall_logical_in cản.htmlm

Tôi cho rằng bạn sẽ không chọn ngôn ngữ chỉ dựa trên điều này :-) Trong mọi trường hợp, bạn có thể thực hiện điều này trong C ++ với một cái gì đó như:

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

Xem chương trình hoàn chỉnh sau đây để biết ví dụ:

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

Kết quả này, như mong đợi:

false
true
false

PostScript , là một concatenative , chồng theo định hướng ngôn ngữ như Forth, có một chuyển đổi unary, không . Các không điều hành Toggles giá trị trên đỉnh của ngăn xếp. Ví dụ,

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

Xem Hướng dẫn tham khảo ngôn ngữ PostScript (pdf) , trang. 458.

Visual Basic.Net hỗ trợ điều này thông qua một phương thức mở rộng.

Xác định phương thức mở rộng như vậy:

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

Và sau đó gọi nó như thế này:

Dim someVariable As Boolean
someVariable = True
someVariable.Flip

Vì vậy, ví dụ ban đầu của bạn sẽ trông giống như:

me.DataSource.TrackedObject.CurrentValue.BooleanFlag.Flip

Trong Rust, bạn có thể tạo đặc điểm của riêng mình để mở rộng các loại thực hiện Nottính trạng đó:

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

Bạn cũng có thể sử dụng ^= truenhư được đề xuất và trong trường hợp của Rust, không có vấn đề nào có thể xảy ra vì đây falsekhông phải là số nguyên "được ngụy trang" như trong C hoặc C ++:

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

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

Trong Python

Python hỗ trợ chức năng như vậy, nếu biến có kiểu bool (đúng hoặc sai) với exclusive or (^=)toán tử:

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

Trong C # :

boolean.variable.down.here ^= true;

Toán tử boolean ^ là XOR và XORing với true cũng giống như đảo ngược.