Provide a simple GSL utility to replace `static_cast<void>`

[GabrielDosReis]

The guidelines recommend avoiding all cast (including static_cast). However, static_cast<void>(expr) is used (and blessed by the C++ standards) as a way to silence function calls whose results shouldn't be ignored. That can be seen as a gnarly hack. Instead, the GSL could provide a facility like

namespace gsl {
   template<typename T>
   inline void drop(T&&) { }
}

to use to ignore the value of an expression. No cast, intent preserved.

[jwakely]

Some people already recommend using std::ignore for that.

[[nodiscard]] bool important_result();
std::ignore = important_result();

[hsutter]

Editors call: Sounds good. Please follow the design of std::ignore (e.g., noexcept) though of course turning it into a function.

[shaneasd]

If std::ignore = presents an acceptable way of achieving this goal what is the rationale for providing an alternative in the gsl?

Although it's not explicit I would read P.13: Use support libraries as appropriate to imply "use the standard library and use gsl if the standard library doesn't have what you need".

Perhaps the clue is in the "of course turning it into a function". Is there an advantage to it being a function?

[beinhaerter]

To extend jwakely and shaneasd answers: the std::ignore = way is what the Guidelines recommend right now in https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es48-avoid-casts.

[mvoronoy]

By the way... (pardon me if it is wrong brnach for discuss the topic). Using of std::ignore can be extremely useful for discarding structured bindings non-imprtant entries. Let's take a look at the following artificial example that contains transfering by value and by reference:

auto make_smthng()
{
    static int value = 11;
    return std::make_pair(42, std::ref(++value));
}

Common consumer of this can look like: std::tie(x, y) = make_smthng();. But what if I don't need one of them and need omit either x or y?
Then std::ignore works well for both:

    std::tie(std::ignore, y) = make_smthng();
    std::tie(x, std::ignore) = make_smthng();

Not sure If I seen this recomendation for std::ignore ever.

[jwakely]

That is exactly the original intended purpose of std::ignore. That's the entire reason it was added to the standard!

Using it to suppress [[nodiscard]] warnings was suggested 20 years later.

[jwakely]

See 6.1.3.2 in https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf

and https://eel.is/c++draft/tuple.creation#6

and https://en.cppreference.com/w/cpp/utility/tuple/ignore.html#Notes