Re: [PATCH v7] rust: add new macro for common bitmap operations

[Kari Argillander]

On Thu, 1 Jan 2026 at 20:21, Filipe Xavier <felipeaggger@xxxxxxxxx> wrote:

> +/// // Combine multiple permissions using operation OR (`|`).
> +/// let read_write: Permissions = Permission::Read | Permission::Write;
> +///
> +/// assert!(read_write.contains(Permission::Read));
> +/// assert!(read_write.contains(Permission::Write));
> +/// assert!(!read_write.contains(Permission::Execute));
> +/// assert!(read_write.contains_any(Permission::Read | Permission::Execute));
> +/// assert!(read_write.contains_all(Permission::Read | Permission::Write));
> +///
> +/// // Removing a permission with operation AND (`&`).
> +/// let read_only: Permissions = read_write & Permission::Read;
> +/// assert!(read_only.contains(Permission::Read));
> +/// assert!(!read_only.contains(Permission::Write));
> +///
> +/// // Toggling permissions with XOR (`^`).
> +/// let toggled: Permissions = read_only ^ Permission::Read;
> +/// assert!(!toggled.contains(Permission::Read));
> +///
> +/// // Inverting permissions with negation (`!`).
> +/// let negated = !read_only;
> +/// assert!(negated.contains(Permission::Write));
> +/// assert!(!negated.contains(Permission::Read));

I really like the OR (`|`) operator. Personally, I don’t like anything
else. When
a function or expression gets longer, something like let negated = !read_only;
already feels strange to read.

My suggestion is that everything else should be functions, so we would write:

```rust
    let xxx = Permission::Read | Permission::Write;
    xxx.remove(Permission::Write | Permission::Read);
    xxx.toggle(Permission::Execute);
    xxx.invert();
```

This way we avoid expressions like:

```rust
    let a = !(!xxx | yyy ^ zzz);
```

At that point, no one understands what is really happening anymore. People start
wondering whether operator precedence or evaluation order matters, and may even
have to go read the source code to figure it out.

By only supporting OR (|) as an operator and expressing everything else as
explicit function calls, the code becomes much easier to read, review, and
maintain.

    Argillander