It declares *immediate functions*, that is, functions that must be evaluated at compile time to produce a constant. (It used to be spelled `constexpr!` in a previous revision of the paper.) In contrast, `constexpr` functions may be evaluated at compile time or run time, and need not produce a constant in all cases.

The adopted paper is [P1073R3](https://wg21.link/P1073R3), which is not yet publicly available, but [a previous revision](https://wg21.link/P1073R2) is available and the introductory (motivation and high-level description) portion is about the same (except that the &quot;Source Locations&quot; section is deleted in R3).

I spent hours just to find out that I misspelt the word `.length` as `.lenght`. It can run normally with no warning at all. Why...?

I use `&#39;use strict&#39;` and run on Node.js 10.13.0.

Code:

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    &#39;use strict&#39;;
    let arr = [1, 2, 3, 4];
    for(let i = 0; i &lt; arr.lenght; i++) {
      console.log(arr[i]);
    }

&lt;!-- end snippet --&gt;


Why doesn&#39;t JavaScript warn me when I use arr.lenght (misspelt) instead of arr.length in a loop? I also use strict mode

I&#39;m trying to install racer using cargo, so I executed the command `cargo install racer` in the terminal and  it resulted in the error:

&lt;!-- language: none --&gt;

    error[E0554]: #![feature] may not be used on the stable release channel
    --&gt; /home/rajkumar/.cargo/registry/src/github.com-1ecc6299db9ec823/scoped-tls-0.1.2/src/lib.rs:47:34
    |
    47 | #![cfg_attr(feature = &quot;nightly&quot;, feature(macro_vis_matcher))]
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^

    error[E0554]: #![feature] may not be used on the stable release channel
    --&gt; /home/rajkumar/.cargo/registry/src/github.com-1ecc6299db9ec823/scoped-tls-0.1.2/src/lib.rs:48:34
    |
    48 | #![cfg_attr(feature = &quot;nightly&quot;, feature(allow_internal_unstable))]
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    error: aborting due to 2 previous errors

    For more information about this error, try `rustc --explain E0554`.
    error: failed to compile `racer v2.1.10`, intermediate artifacts can be found at `/tmp/cargo-install5YWPWW`

    Caused by:
    Could not compile `scoped-tls`.

    To learn more, run the command again with --verbose.

Below are my Rust details:

&lt;!-- language: none --&gt;

    $rustc --version
    rustc 1.30.0 (da5f414c2 2018-10-24)

    &gt; rustup --version 
    rustup 1.14.0 (1e51b07cc 2018-10-04)

    &gt; cargo --version 
    cargo 1.30.0 (36d96825d 2018-10-24)

Below is my opensuse version details:

&lt;!-- language: none --&gt;

    &gt; cat /usr/lib/os-release 
    NAME=&quot;openSUSE Tumbleweed&quot;
    # VERSION=&quot;20181029&quot;
    ID=&quot;opensuse-tumbleweed&quot;
    ID_LIKE=&quot;opensuse suse&quot;
    VERSION_ID=&quot;20181029&quot;
    PRETTY_NAME=&quot;openSUSE Tumbleweed&quot;
    ANSI_COLOR=&quot;0;32&quot;
    CPE_NAME=&quot;cpe:/o:opensuse:tumbleweed:20181029&quot;
    BUG_REPORT_URL=&quot;https://bugs.opensuse.org&quot;
    HOME_URL=&quot;https://www.opensuse.org/&quot;

Why am I not able to install racer using cargo? Am I missing anything?

error[E0554]: #![feature] may not be used on the stable release channel Couldn&#39;t install racer using cargo

Apparently, `consteval` is going to be a keyword in C++20. The [cppreference page][1] for it is currently blank. What is it going to be and how does it relate to `constexpr`?


  [1]: https://en.cppreference.com/w/cpp/keyword/consteval

What is consteval?

<p>Apparently, <code>consteval</code> is going to be a keyword in C++20. The <a href="https://en.cppreference.com/w/cpp/keyword/consteval" target="_blank" rel="noopener noreferrer">cppreference page</a> for it is currently blank. What is it going to be and how does it relate to <code>constexpr</code>?</p>


According to the last meeting of the ISO C++ Committee, [bit-cast][1] will be introduced in C++20 standard.

I know that `reinterpret_cast` is not suitable for this job due to [type aliasing rules][2] but my question is why did they choose not to extend the `reinterpret_cast` to treat the object like it bit sequence representation and preferred to give this functionality as a new language construct?


  [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0476r2.html
  [2]: https://en.cppreference.com/w/cpp/language/reinterpret_cast#Type_aliasing

C++20 bit_cast vs reinterpret_cast

What&#39;s the point of telling the compiler specifically to include the file only once? Wouldn&#39;t it make sense by default? Is there even any reason to include a single file multiple times? Why not just assume it? Is it to do with specific hardware?

Why isn&#39;t #pragma once automatically assumed?

Related to questions [How do I check for C++11 support?][1] and [https://stackoverflow.com/questions/38456127/what-is-the-value-of-cplusplus-for-c17][2]

How can I inquire whether the compiler can handle / is set up to use C++20? I know that it is, in principle, possible to inquire the C++ version by:

    #if __cplusplus &gt; ???
      // C++20 code here
    #endif

What should `???` be for C++20?


  [1]: https://stackoverflow.com/questions/5047971/how-do-i-check-for-c11-support
  [2]: https://stackoverflow.com/questions/38456127/what-is-the-value-of-cplusplus-for-c17

How do I check for C++20 support? What is the value of __cplusplus for C++20?

I have four `bool` values:

    bool bValue1;
    bool bValue2;
    bool bValue3;
    bool bValue4;

The acceptable values are:

             Scenario 1 | Scenario 2 | Scenario 3
    bValue1: true       | true       | true
    bValue2: true       | true       | false
    bValue3: true       | true       | false
    bValue4: true       | false      | false

So, for example, this scenario is not acceptable:

    bValue1: false
    bValue2: true
    bValue3: true
    bValue4: true

At the moment I have come up with this `if` statement to detect bad scenarios:

    if(((bValue4 &amp;&amp; (!bValue3 || !bValue2 || !bValue1)) ||
       ((bValue3 &amp;&amp; (!bValue2 || !bValue1)) ||
       (bValue2 &amp;&amp; !bValue1) ||
       (!bValue1 &amp;&amp; !bValue2 &amp;&amp; !bValue3 &amp;&amp; !bValue4))
    {
        // There is some error
    }

Can that statement logic be improved/simplified?

How to improve logic to check whether 4 boolean values match some cases

What does the *g* stand for in `std::iostream`&#39;s `gcount`, `tellg` and `seekg` members? And the *p* in `pcount`, `tellp` and `seekp`?

Why aren&#39;t they called just `count`, `tell` and `seek`?

What does the g stand for in gcount, tellg and seekg?

I noticed that most if not all containers now require their `::iterator` type to satisfy `LegacySomethingIterator` instead of `SomethingIterator`. 

For example, `std::vector&lt;&gt;::iterator` [now requires](https://en.cppreference.com/w/cpp/container/vector):

&gt; `iterator` 	[_LegacyRandomAccessIterator_](https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator)


This seems to be the same for most of the other containers, all requiring their iterators to go from `SomethingIterator` to `LegacySomethingIterator`.

There are also the &quot;new&quot; requirements that took the names of the old requirements, such as [`RandomAccessIterator`](https://en.cppreference.com/w/cpp/experimental/ranges/iterator/RandomAccessIterator), why were these added? It seems to me that the new variants just shadow the legacy variants, no differences.

Why were new ones created in the first place, their requirements look the same to me. Why don&#39;t the new ones just replace the old requirements instead of right now having 2 different names for them (e.g. `RandomAccessIterator` and `LegacyRandomAccessIterator`)?

New iterator requirements

[tag:c++14] introduced generic lambdas that made it possible to write following:

    auto func = [](auto a, auto b){
        return a + b;
    };
    auto Foo = func(2, 5);
    auto Bar = func(&quot;hello&quot;, &quot;world&quot;);

It is very clear that this generic lambda `func` works just like a templated function `func` would work.

Why did the C++ committee decide to add template syntax for generic lamda?



What is the need of template lambda introduced in C++20 when C++14 already has generic lambda?

One of the corners of C++20 concepts is that there are certain situations in which you have to write `requires requires`. For instance, this example from [\[expr.prim.req\]/3](http://eel.is/c++draft/expr#prim.req-3):

&gt; A _requires-expression_ can also be used in a _requires-clause_ ([temp]) as a way of writing ad hoc constraints on template arguments such as the one below:
&gt;
&gt; 
    template&lt;typename T&gt;
      requires requires (T x) { x + x; }
        T add(T a, T b) { return a + b; }

&gt; The first requires introduces the _requires-clause_, and the second introduces the _requires-expression_. 

What is the technical reason behind needing that second `requires` keyword? Why can&#39;t we just allow writing:

    template&lt;typename T&gt;
      requires (T x) { x + x; }
        T add(T a, T b) { return a + b; }

&lt;sub&gt;(Note: please don&#39;t answer that the grammar `requires` it)&lt;/sub&gt;

Content Type	Original Author	Original Content on Stackoverflow
Question	KevinZ	View Question on Stackoverflow
Solution 1 - C++	T.C.	View Answer on Stackoverflow

What is consteval?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

error[E0554]: #![feature] may not be used on the stable release channel Couldn't install racer using cargo

Why doesn't JavaScript warn me when I use arr.lenght (misspelt) instead of arr.length in a loop? I also use strict mode

Attributions