The [**`!` operator**](https://doc.rust-lang.org/stable/std/ops/trait.Not.html) is implemented for many primitive types and it&#39;s equivalent to the `~` operator in C. See this example ([playground](https://play.rust-lang.org/?gist=dc71248cd9f687cb1e43257eb382e529&amp;version=stable&amp;backtrace=0)):

    let x = 0b10101010u8;
    let y = !x;
    println!(&quot;x: {:0&gt;8b}&quot;, x);
    println!(&quot;y: {:0&gt;8b}&quot;, y);

Outputs:

&gt; &lt;!-- language: none --&gt;
&gt;
&gt;     x: 10101010
&gt;     y: 01010101

See also:

- https://stackoverflow.com/q/40467995/155423

After much googling I&#39;ve found a lot about marking functions and their parameters as `const`, but no guide on marking variables as `const`.

Here&#39;s a really simple example:

    #include &lt;string&gt;
    #include &lt;iostream&gt;
    
    void example(const std::string&amp; x) {
      size_t length = x.length();
      for (size_t i = 0; i &lt; length; ++i) {
        std::cout &lt;&lt; x.at(i) &lt;&lt; std::endl;
      }
    }
    
    int main() {
      example(&quot;hello&quot;);
    }

Why not make 

    size_t length = x.length();

const like

    const size_t length = x.length();

by convention?

I know such a small, simple example really doesn&#39;t show any huge benefit to this, but it seems like it&#39;d be helpful in a larger codebase where you might accidentally mutate a variable you shouldn&#39;t have mutated.

Despite that benefit, I don&#39;t really see it used that much (in the C++ codebases I&#39;ve seen) or mentioned nearly as much as making functions and their parameters `const`.

Is there some downside to doing this other than having to type 5 extra characters? I haven&#39;t found much on the topic, and I don&#39;t want to shoot myself in the foot if it&#39;s a problem having so many consts.

Are there any downsides to marking all variables you don&#39;t modify const?

I have a basic bar graph I&#39;ve created from ggplot2. The y variable contains both positive and negative values and about half the vector of values are negative. I would like to customize the axis labels such that when the y value of that corresponding x factor is a negative, its label is red. Here&#39;s a reproducible example:

    #Create data
    x &lt;- c(&quot;a&quot;,&quot;b&quot;,&quot;c&quot;,&quot;d&quot;,&quot;e&quot;,&quot;f&quot;)
    y &lt;- c(&quot;10&quot;, &quot;9&quot;,&quot;-10&quot;,&quot;11&quot;,&quot;-3&quot;,&quot;-15&quot;)
    data &lt;- data.frame(x, y)
    data$y &lt;- as.numeric(as.character(data$y))

    data$category &lt;- ifelse(as.numeric(data$y)&lt;0, 0, 1)
    data$category &lt;- as.factor(data$category)
    
    #Graph
    library(cowplot) #theme
    library(ggplot2)

    ggplot(data, aes(x=x, y=y)) + 
      geom_bar(stat = &quot;identity&quot;, aes(fill=category)) +
      theme(axis.text.x = element_text(angle = 45, hjust = 1)) +
      theme(axis.text.x = element_text(colour = &quot;black&quot;))

[![enter image description here][1]][1]
      
What I need is a way to change the label colors of &quot;c&quot;, &quot;e&quot;, and &quot;f&quot; to the color of my choosing. I tried toggling ``theme(aes(axis.text.x=element_text(colour=Air_pricier)))`` but that produced an error. Thanks in advance.

  [1]: http://i.stack.imgur.com/kwoKZ.png

customize ggplot2 axis labels with different colors

Looking at the [list of bitwise operators in the Rust Book][1], I don&#39;t see a NOT operator (like `~` in C).  Is there no NOT operator in Rust?


  [1]: https://doc.rust-lang.org/reference.html#bitwise-operators

What is the bitwise NOT operator in Rust?

<p>Looking at the <a href="https://doc.rust-lang.org/reference.html#bitwise-operators" target="_blank" rel="noopener noreferrer">list of bitwise operators in the Rust Book</a>, I don't see a NOT operator (like <code>~</code> in C).  Is there no NOT operator in Rust?</p>


With the C pre-processor it&#39;s common to do,

&lt;!-- language: C --&gt;

    #if defined(NDEBUG)
        // release build
    #endif

    #if defined(DEBUG)
        // debug build
    #endif

Cargo&#39;s rough equivalents are:

- `cargo build --release` for release.
- `cargo build` for debug.

How would Rust&#39;s `#[cfg(...)]` attribute or `cfg!(...)` macro be used to do something similar?

I understand that Rust&#39;s pre-processor doesn&#39;t work like C&#39;s. I checked the documentation and [this page lists some attributes][1]. *(assuming this list is comprehensive)*

`debug_assertions` could be checked, but it may be misleading when used to check for the more general debugging case.

I&#39;m not sure if this question should be related to Cargo or not.

  [1]: https://doc.rust-lang.org/reference.html#conditional-compilation

How to check release / debug builds using cfg in Rust?

While I&#39;ve seen docs on using `rustc` directly to output assembly, having to manually extract commands used by Cargo and edit them to write assembly is tedious.

Is there a way to run Cargo that writes out assembly files?

How to get assembly output from building with Cargo?

Is it at all possible to define functions inside of traits as having `impl Trait` return types?  I want to create a trait that can be implemented by multiple structs so that the `new()` functions of all of them returns an object that they can all be used in the same way without having to write code specific to each one.

```
trait A {
    fn new() -&gt; impl A;
}
```

However, I get the following error:

```none
error[E0562]: `impl Trait` not allowed outside of function and inherent method return types
 --&gt; src/lib.rs:2:17
  |
2 |     fn new() -&gt; impl A;
  |                 ^^^^^^
```

Is this a limitation of the current implementation of `impl Trait` or am I using it wrong?

Is it possible to use `impl Trait` as a function&#39;s return type in a trait definition?

I can not find within the documentation of `Vec&lt;T&gt;` how to retrieve a slice from  a specified range.

Is there something like this in the standard library:

    let a = vec![1, 2, 3, 4];
    let suba = a.subvector(0, 2); // Contains [1, 2];

How do I get a slice of a Vec&lt;T&gt; in Rust?

I want to build a `HashSet&lt;u8&gt;` from a `Vec&lt;u8&gt;`. I&#39;d like to do this

1. in one line of code,
2. copying the data only once,
3. using only `2n` memory, 

but the only thing I can get to compile is this piece of .. junk, which I think copies the data twice and uses `3n` memory.

    fn vec_to_set(vec: Vec&lt;u8&gt;) -&gt; HashSet&lt;u8&gt; {
        let mut victim = vec.clone();
        let x: HashSet&lt;u8&gt; = victim.drain(..).collect();
        return x;
    }

I was hoping to write something simple, like this:

    fn vec_to_set(vec: Vec&lt;u8&gt;) -&gt; HashSet&lt;u8&gt; {
        return HashSet::from_iter(vec.iter());
    }

but that won&#39;t compile:

&lt;!-- language: none --&gt;

    error[E0308]: mismatched types
     --&gt; &lt;anon&gt;:5:12
      |
    5 |     return HashSet::from_iter(vec.iter());
      |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected u8, found &amp;u8
      |
      = note: expected type `std::collections::HashSet&lt;u8&gt;`
      = note:    found type `std::collections::HashSet&lt;&amp;u8, _&gt;`

.. and I don&#39;t really understand the error message, probably because I need to RTFM.

Build HashSet from a vector in Rust

While I am installing Magento 2 on my Server, I got an error. After investigating the code and found that there is are three dots (`...`), which is producing the error. I included the code I found below:
```php
return new $type(...array_values($args));
```
What is this operator called, and what is its purpose?

What is the meaning of three dots (...) in PHP?

I found out a curious thing today and was wondering if somebody could shed some light into what the difference is here?

    import numpy as np

    A = np.arange(12).reshape(4,3)
    for a in A:
        a = a + 1

    B = np.arange(12).reshape(4,3)
    for b in B:
        b += 1

After running each `for` loop, `A` has not changed, but `B` has had one added to each element. I actually use the `B` version to write to a initialized NumPy array within a `for` loop.



What is the difference between i = i + 1 and i += 1 in a &#39;for&#39; loop?

Probably a little bit broad question, but the official documentation doesn&#39;t even mentioning the arrow operator (or language construct, I don&#39;t know which phrase is more accurate) as an independent entity.

The most obvious use is the when conditional statement, where it is used to assign an expression to a specific condition:

      val greet = when(args[0]) {
        &quot;Appul&quot; -&gt; &quot;howdy!&quot;
        &quot;Orang&quot; -&gt; &quot;wazzup?&quot;
        &quot;Banan&quot; -&gt; &quot;bonjur!&quot;
        else    -&gt; &quot;hi!&quot;
      }
      
      println(args[0] +&quot; greets you: \&quot;&quot;+ greet +&quot;\&quot;&quot;)

What are the other uses, and what are they do?
Is there a general meaning of the arrow operator in Kotlin?

What does the arrow (&quot;-&gt;&quot;) operator do in Kotlin?

I fell on [this page](http://www.akiwi.co.uk/programming.html) where the author talks about the *standardisation of the operator &quot;&quot;*:

&gt; The decision of the C++ standards committee to **standardise `operator &quot;&quot;`**
&gt; was [...]

What is he/she talking about? I can&#39;t find any information about this, and I don&#39;t understand what it could imply (overload for constant strings? Or something more conceptual, that doesn&#39;t affect the final use of the language?)



What is the operator &quot;&quot; in C++?

I recently came across a syntax I never seen before when I learned python nor in most tutorials, the `..` notation, it looks something like this:

    f = 1..__truediv__ # or 1..__div__ for python 2
    
    print(f(8)) # prints 0.125 

I figured it was exactly the same as (except it&#39;s longer, of course):

    f = lambda x: (1).__truediv__(x)
    print(f(8)) # prints 0.125 or 1//8

But my questions are: 

* How can it do that?  
* What does it actually mean with the two dots? 
* How can you use it in a more complex statement (if possible)? 

This will probably save me many lines of code in the future...:)

Content Type	Original Author	Original Content on Stackoverflow
Question	Verax	View Question on Stackoverflow
Solution 1 - Rust	Lukas Kalbertodt	View Answer on Stackoverflow

What is the bitwise NOT operator in Rust?

Rust Problem Overview

Rust Solutions

Solution 1 - Rust

customize ggplot2 axis labels with different colors

Are there any downsides to marking all variables you don't modify const?

Attributions