One limitation of the current Rust compiler is that it if you&#39;re not using LTO (Link-Time Optimization), it will never inline a function not marked `#[inline]` across crates. Rust uses a separate compilation model similar to C++ because LLVM&#39;s LTO implementation doesn&#39;t scale well to large projects. Therefore, small functions exposed to other crates need to be marked by hand.  This isn&#39;t a great situation, and it&#39;s likely to be fixed in the future by some combination of improvements to LTO and MIR inlining.

`#[inline(never)]` is sometimes useful for debugging (separating a piece of code which isn&#39;t working as expected). In theory, it can be used for benchmarking, but that&#39;s usually a bad idea: turning off inlining doesn&#39;t prevent other inter-procedural optimizations like constant propagation. In terms of normal code, it can reduce codesize if you have a frequently used helper function which is only used for error handling.

`#[inline(always)]` is generally bad idea; if a function is big enough that the compiler won&#39;t inline it by default, it&#39;s big enough that the overhead of the call doesn&#39;t matter (and excessive inlining increases instruction cache pressure).  There are exceptions, but you need performance measurements to justify it. [This example](https://github.com/rust-lang/rust/commit/274bb24efdbeed0ab1a91f3c02f86551ef16eac7) is the sort of situation where it&#39;s worth considering.  `#[inline(always)]` can also be used to improve `-O0` code quality, but that&#39;s not usually worth worrying about.

At the 2016 Oulu ISO C++ Standards meeting, a proposal called [Guaranteed copy elision through simplified value categories](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0135r0.html) was voted into C++17 by the standards committee.

How exactly does guaranteed copy elision work? Does it cover some cases where copy elision was already permitted, or are code changes needed to guarantee copy elision?

How does guaranteed copy elision work?

I&#39;m trying to invoke a lambda function from node.
```javascript
var aws = require(&#39;aws-sdk&#39;);
var lambda = new aws.Lambda({
    accessKeyId: &#39;id&#39;,
    secretAccessKey: &#39;key&#39;,
    region: &#39;us-west-2&#39;
});

lambda.invoke({
    FunctionName: &#39;test1&#39;,
    Payload: JSON.stringify({
        key1: &#39;Arjun&#39;,
        key2: &#39;kom&#39;,
        key3: &#39;ath&#39;
    })
}, function(err, data) {
    if (err) console.log(err, err.stack);
    else     console.log(data);
});
```

The keys are for an IAM user. The user has `AWSLambdaExecute` and `AWSLambdaBasicExecutionRole` policies attached.

I get a permission error:
`AccessDeniedException: User: arn:aws:iam::1221321312:user/cli is not authorized to perform: lambda:InvokeFunction on resource: arn:aws:lambda:us-west-2:1221321312:function:test1`

I read the docs and several blogs, but I&#39;m unable to authorise this user to invoke the lambda function. How do get this user to invoke lambda?


AccessDeniedException: User is not authorized to perform: lambda:InvokeFunction

Rust has an &quot;inline&quot; attribute that can be used in one of those three flavors:

`#[inline]`

`#[inline(always)]`

`#[inline(never)]`

When should they be used?

In the Rust reference, we see [an inline attributes section][1] saying

&gt; The compiler automatically inlines functions based on internal heuristics. Incorrectly inlining functions can actually make the program slower, so it should be used with care.

In the Rust internals forum, huon was also [conservative about specifying inline][2].

But we see [considerable usage][3] in the Rust source, including the standard library. A lot of inline attributes are added to one-line-functions, which should be easy for the compilers to spot and optimize through heuristics according to the reference. Are those in fact not needed?


  [1]: https://doc.rust-lang.org/reference.html#inline-attributes
  [2]: https://internals.rust-lang.org/t/when-should-i-use-inline/598/3?u=wisagan
  [3]: https://github.com/rust-lang/rust/search?utf8=%E2%9C%93&amp;q=inline&amp;type=Code

When should inline be used in Rust?

Rust has an "inline" attribute that can be used in one of those three flavors:
<code>#[inline]</code>
<code>#[inline(always)]</code>
<code>#[inline(never)]</code>
When should they be used?
In the Rust reference, we see <a href="https://doc.rust-lang.org/reference.html#inline-attributes" target="_blank" rel="noopener noreferrer">an inline attributes section</a> saying
> The compiler automatically inlines functions based on internal heuristics. Incorrectly inlining functions can actually make the program slower, so it should be used with care.
In the Rust internals forum, huon was also <a href="https://internals.rust-lang.org/t/when-should-i-use-inline/598/3?u=wisagan" target="_blank" rel="noopener noreferrer">conservative about specifying inline</a>.
But we see <a href="https://github.com/rust-lang/rust/search?utf8=%E2%9C%93&#x26;q=inline&#x26;type=Code" target="_blank" rel="noopener noreferrer">considerable usage</a> in the Rust source, including the standard library. A lot of inline attributes are added to one-line-functions, which should be easy for the compilers to spot and optimize through heuristics according to the reference. Are those in fact not needed?

I learned that if a variable is not explicitly declared mutable using `mut`, it becomes immutable (it cannot be changed after declaration). Then why do we have the `const` keyword in Rust? Aren&#39;t they same? If not, how do they differ?

What is the difference between immutable and const variables in Rust?

I have something like this (the real function is `Ini::Section::get` from [rust-ini][1]):

``` 
impl Foo {
    pub fn get&lt;K&gt;(&amp;&#39;a mut self, key: &amp;K) -&gt; Option&lt;&amp;&#39;a str&gt;
    where
        K: Hash + Eq,
    {
        // ...
    }
}
```

I have to call it several times:

```
fn new() -&gt; Result&lt;Boo, String&gt; {
    let item1 = match section.get(&quot;item1&quot;) {
        None =&gt; return Result::Err(&quot;no item1&quot;.to_string()),
        Some(v) =&gt; v,
    };
    let item2 = match section.get(&quot;item2&quot;) {
        None =&gt; return Result::Err(&quot;no item2&quot;.to_string()),
        Some(v) =&gt; v,
    };
}
```

To remove code bloat, I can write a macro like this:
  
    macro_rules! try_ini_get {
        ($e:expr) =&gt; {
            match $e {
                Some(s) =&gt; s,
                None =&gt; return Result::Err(&quot;no ini item&quot;.to_string()),
            }
        }
    }

Is there any way to remove the code duplication without this macro implementation?

  [1]: https://github.com/zonyitoo/rust-ini





Is there a way to simplify converting an Option into a Result without a macro?

I seem to have diverging versions of `rustc` and `cargo` (I think), 

&lt;!-- language: none --&gt;

    $ rustc -V
    rustc 1.9.0 (e4e8b6668 2016-05-18)
    $ cargo -V
    cargo 0.10.0-nightly (10ddd7d 2016-04-08)

Is there a command akin to 

&lt;!-- language: none --&gt;

    pip install --upgrade pip 

for upgrading `cargo`? I.e. something like

&lt;!-- language: none --&gt;

    cargo install --upgrade cargo

Is there a command to update Cargo to the latest official release?

I have an enum in Rust which has one value that takes a `String`:

```
#[derive(Clone, Copy)]
enum Simple {
    Error(String),
    Okay,
    Foo([u32; 5]),
}

fn main() {
    let x = Simple::Error(String::from(&quot;blah&quot;));
    let y = x.clone();
}
```

The enum value `Foo` above represents about 10 other enums I use that take copyable types or arrays of them. The compiler doesn&#39;t seem to complain about them, only the `Error(String)` which causes this:

```none
error[E0204]: the trait `Copy` may not be implemented for this type
 --&gt; src/main.rs:1:17
  |
1 | #[derive(Clone, Copy)]
  |                 ^^^^
2 | enum Simple {
3 |     Error(String),
  |           ------ this field does not implement `Copy`
  |
```

For some reason, `String` is not copyable. I don&#39;t get this. How do I implement `Clone` for an enum for just the one type which has a problem while using the default impl for the rest?


How do I implement Copy and Clone for a type that contains a String (or any type that doesn&#39;t implement Copy)?

I&#39;d like to capitalize the first letter of a `&amp;str`. It&#39;s a simple problem and I hope for a simple solution. Intuition tells me to do something like this:

    let mut s = &quot;foobar&quot;;
    s[0] = s[0].to_uppercase();

But `&amp;str`s can&#39;t be indexed like this. The only way I&#39;ve been able to do it seems overly convoluted. I convert the `&amp;str` to an iterator, convert the iterator to a vector, upper case the first item in the vector, which creates an iterator, which I index into, creating an `Option`, which I unwrap to give me the upper-cased first letter. Then I convert the vector into an iterator, which I convert into a `String`, which I convert to a `&amp;str`.

    let s1 = &quot;foobar&quot;;
    let mut v: Vec&lt;char&gt; = s1.chars().collect();
    v[0] = v[0].to_uppercase().nth(0).unwrap();
    let s2: String = v.into_iter().collect();
    let s3 = &amp;s2;

Is there an easier way than this, and if so, what? If not, why is Rust designed this way?

[Similar question](https://stackoverflow.com/questions/38342805/how-do-i-collect-from-multiple-iterator-types#)

Why is capitalizing the first letter of a string so convoluted in Rust?

I have two questions:

1) Why are pointers to inline functions allowed in C++?
I have read that the code of inline functions just gets copied to the function call statement and there is no compile-time memory allocation in inline functions. So why can a pointer exist to an inline function, given that there is no fixed memory address for inline functions?

2) Consider the code below:

    inline void func()    
    {
        int n=0;
        cout&lt;&lt;(&amp;n);
    } 

Should it not print different values of the address of `n` each time `func()` is called? 
[Because I think that every time inline function code is copied, reallocation of the local variables must be done (whereas in the case of normal functions, reinitialisation takes place)]

I am a beginner and I asked this question for the sake of my concept strengthening. Please correct me if I am wrong anywhere.

Why are pointers to inline functions allowed?

I know that an *&quot;undefined behaviour&quot;* in C++ can pretty much allow the compiler to do anything it wants. However, I had a crash that surprised me, as I assumed that the code was safe enough.

In this case, the real problem happened only on a specific platform using a specific compiler, and only if optimization was enabled.

I tried several things in order to reproduce the problem and simplify it to the maximum. Here&#39;s an extract of a function called `Serialize`, that would take a bool parameter, and copy the string `true` or `false` to an existing destination buffer.

Would this function be in a code review, there would be no way to tell that it, in fact, could crash if the bool parameter was an uninitialized value?

    // Zero-filled global buffer of 16 characters
    char destBuffer[16];
    
    void Serialize(bool boolValue) {
        // Determine which string to print based on boolValue
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        const size_t len = strlen(whichString);
        
        // Copy string into destination buffer, which is zero-filled (thus already null-terminated)
        memcpy(destBuffer, whichString, len);
    }

If this code is executed with clang 5.0.0 + optimizations, it will/can crash.

The expected ternary-operator `boolValue ? &quot;true&quot; : &quot;false&quot;` looked safe enough for me, I was assuming, &quot;Whatever garbage value is in `boolValue` doesn&#39;t matter, since it will evaluate to true or false anyhow.&quot;

I have setup a [Compiler Explorer example](https://godbolt.org/z/DoFmhA) that shows the problem in the disassembly, here the complete example. *Note: in order to repro the issue, the combination I&#39;ve found that worked is by using Clang 5.0.0 with -O2 optimisation.*

    #include &lt;iostream&gt;
    #include &lt;cstring&gt;
    
    // Simple struct, with an empty constructor that doesn&#39;t initialize anything
    struct FStruct {
        bool uninitializedBool;
        
       __attribute__ ((noinline))  // Note: the constructor must be declared noinline to trigger the problem
       FStruct() {};
    };
    
    char destBuffer[16];
    
    // Small utility function that allocates and returns a string &quot;true&quot; or &quot;false&quot; depending on the value of the parameter
    void Serialize(bool boolValue) {
        // Determine which string to print depending if &#39;boolValue&#39; is evaluated as true or false
        const char* whichString = boolValue ? &quot;true&quot; : &quot;false&quot;;
        
        // Compute the length of the string we selected
        size_t len = strlen(whichString);
        
        memcpy(destBuffer, whichString, len);
    }
    
    int main()
    {
        // Locally construct an instance of our struct here on the stack. The bool member uninitializedBool is uninitialized.
        FStruct structInstance;
        
        // Output &quot;true&quot; or &quot;false&quot; to stdout
        Serialize(structInstance.uninitializedBool);
        return 0;
    }

The problem arises because of the optimizer: It was clever enough to deduce that the strings &quot;true&quot; and &quot;false&quot; only differs in length by 1. So instead of really calculating the length, it uses the value of the bool itself, which *should* technically be either 0 or 1, and goes like this:

    const size_t len = strlen(whichString); // original code
    const size_t len = 5 - boolValue;       // clang clever optimization

While this is &quot;clever&quot;, so to speak, my question is: **Does the C++ standard allow a compiler to assume a bool can only have an internal numerical representation of &#39;0&#39; or &#39;1&#39; and use it in such a way?**

Or is this a case of implementation-defined, in which case the implementation assumed that all its bools will only ever contain 0 or 1, and any other value is undefined behaviour territory?

Does the C++ standard allow for an uninitialized bool to crash a program?

As far as I know, reference/pointer aliasing can hinder the compiler&#39;s ability to generate optimized code, since they must ensure the generated binary behaves correctly in the case where the two references/pointers indeed alias. For instance, in the following C code,

```c
void adds(int  *a, int *b) {
    *a += *b;
    *a += *b;
}
```

when compiled by `clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)` with the `-O3` flag, it emits

```none
0000000000000000 &lt;adds&gt;:
   0:    8b 07                    mov    (%rdi),%eax  # load a into EAX
   2:    03 06                    add    (%rsi),%eax  # load-and-add b
   4:    89 07                    mov    %eax,(%rdi)  # store into a
   6:    03 06                    add    (%rsi),%eax  # load-and-add b again
   8:    89 07                    mov    %eax,(%rdi)  # store into a again
   a:    c3                       retq
```

Here the code stores back to `(%rdi)` twice in case `int *a` and `int *b` alias.

When we explicitly tell the compiler that these two pointers cannot alias with the `restrict` keyword:

```c
void adds(int * restrict a, int * restrict b) {
    *a += *b;
    *a += *b;
}
```

Then Clang will emit a more optimized version that effectively does `*a += 2 * (*b)`, which is equivalent if (as promised by `restrict`) `*b` isn&#39;t modified by assigning to `*a`:

```none
0000000000000000 &lt;adds&gt;:
   0:    8b 06                    mov    (%rsi),%eax   # load b once
   2:    01 c0                    add    %eax,%eax     # double it
   4:    01 07                    add    %eax,(%rdi)   # *a += 2 * (*b)
   6:    c3                       retq
```

Since Rust makes sure (except in unsafe code) that two mutable references cannot alias, I would think that the compiler should be able to emit the more optimized version of the code.

When I test with the code below and compile it with `rustc 1.35.0` with `-C opt-level=3 --emit obj`,

```rust
#![crate_type = &quot;staticlib&quot;]
#[no_mangle]
fn adds(a: &amp;mut i32, b: &amp;mut i32) {
    *a += *b;
    *a += *b;
}
```

it generates:

```none
0000000000000000 &lt;adds&gt;:
   0:    8b 07                    mov    (%rdi),%eax
   2:    03 06                    add    (%rsi),%eax
   4:    89 07                    mov    %eax,(%rdi)
   6:    03 06                    add    (%rsi),%eax
   8:    89 07                    mov    %eax,(%rdi)
   a:    c3                       retq
```

This does not take advantage of the guarantee that `a` and `b` cannot alias.

Is this because the current Rust compiler is still in development and has not yet incorporated alias analysis to do the optimization?

Is this because there is still a chance that `a` and `b` could alias, even in safe Rust?


Why does the Rust compiler not optimize code assuming that two mutable references cannot alias?

Rust has 128-bit integers, these are denoted with the data type `i128` (and `u128` for unsigned ints):

    let a: i128 = 170141183460469231731687303715884105727;

How does Rust make these `i128` values work on a 64-bit system; e.g. how does it do arithmetic on these?

Since, as far as I know, the value cannot fit in one register of a x86-64 CPU, does the compiler somehow use two registers for one `i128` value? Or are they instead using some kind of big integer struct to represent them?

How does Rust&#39;s 128-bit integer `i128` work on a 64-bit system?

When running a sum loop over an array in Rust, I noticed a huge performance drop when `CAPACITY` &gt;= 240. `CAPACITY` = 239 is about 80 times faster. 

Is there special compilation optimization Rust is doing for &quot;short&quot; arrays? 

Compiled with `rustc -C opt-level=3`.

```rust
use std::time::Instant;

const CAPACITY: usize = 240;
const IN_LOOPS: usize = 500000;

fn main() {
    let mut arr = [0; CAPACITY];
    for i in 0..CAPACITY {
        arr[i] = i;
    }
    let mut sum = 0;
    let now = Instant::now();
    for _ in 0..IN_LOOPS {
        let mut s = 0;
        for i in 0..arr.len() {
            s += arr[i];
        }
        sum += s;
    }
    println!(&quot;sum:{} time:{:?}&quot;, sum, now.elapsed());
}
```

Content Type	Original Author	Original Content on Stackoverflow
Question	WiSaGaN	View Question on Stackoverflow
Solution 1 - Rust	Eli Friedman	View Answer on Stackoverflow

When should inline be used in Rust?

Rust Problem Overview

Rust Solutions

Solution 1 - Rust

AccessDeniedException: User is not authorized to perform: lambda:InvokeFunction

How does guaranteed copy elision work?

Attributions