# V1080\. Call of 'std::is\_constant\_evaluated' function always returns the same value\.

The diagnostic rule warns that the 'std::is\_constant\_evaluated' function's return value has no ability to ever change\. This may lead to unreachable code\. 

This rule covers two cases:

* The function is called in the context, that is always the compile\-time context, and returns 'true'\. 
* The function is called in the context, that is always the runtime context, and returns 'false'\.

Example: we need to write a function that would contain two versions of one algorithm \- one version for compile\-time, the other version for runtime\. We'll use the 'std::is\_constant\_evaluated' function to differentiate between these two implementations\.

```cpp
#include <type_traits>

constexpr void foo()
{
  constexpr auto context = std::is_constant_evaluated();
  //....
  if (context)
  {
    // compile-time logic
  }
  else
  {
    // runtime logic
  }
}
```

Here the 'std::is\_constant\_evaluated' function always returns 'true'\. The 'else' branch contains unreachable code\.

The opposite situation may happen if we remove the 'costexpr' specifier from the 'context' variable and from the 'foo' function\.

```cpp
#include <type_traits>

void foo()
{
  auto context = std::is_constant_evaluated();
  //....
  if (context)
  {
    // compile-time logic
  }
  else
  {
    // runtime logic
  }
}
```

Here the 'context' variable is always 'false'\. The code becomes unreachable as early as the 'then' branch\.

The 'std::is\_constant\_evaluated' always returns 'true' if called in one of the following locations:

* inside 'static\_assert';
* inside the 'consteval' function;
* inside the 'if constexpr' condition\.

The 'std::is\_constant\_evaluated' always returns 'true' if called here:

* inside a function that is not marked with the 'constexpr' / 'consteval' specifiers\.