unused-variables

There are many times when as I am debugging, or reusing some code, the file starts to acquire lines that don't do anything, though they may have done something at one point. Things like vectors and getting filled, and then go unused, classes/structs that are defined but never used, and functions that are declared, but never used. I understand that in many cases, some of these things are not superfluous, as they might be visible from other files, but in my case, there are no other files, just extraneous code in my file. While I understand that technically speaking, invoking push_back does

When I compile my typescript project, I'm using the noImplicitAny option so that I won't forget to specify the types on my variables and arguments. However sometimes you have arguments that you don't use. For example: jQuery.ajaxTransport("+*", function (options: JQueryAjaxSettings) { return { abort: function (_, callback: JQueryCallback) { I am not interested in the first argument of the abort function, so I ignore it by naming it _. Is that the proper way to do that in TypeScript? I couldn't find it in the guide. I suspect that it isn't the proper way, because I can only name one argument _.

I'm developing in golang and I run the following for loop: // Define Initial Value i := 0 for { // Get Random data based on iteration data, i := GiveRandomData(i) // Save to database response, err := SaveToDatabase(data) if err != nil { log.Fatal(err) } fmt.Println(response) } However, when compiling this program, I get the following error: .\main.go:26: i declared and not used The Golang compiler doesn't seem to recognise that the i variable is given back to the function in the next loop. Inside this function, the I variable changes value. What should I do to get rid of this compilation error

I am learning Rust, and came across the fact that adding an underscore at the beginning of a variable name will make the compiler not warn if it is unused. I am wondering why that feature exists, since unused variables are frowned upon. I can see several reasons: Your are calling a function that returns a #[must_use] type, but in your specific case, you know you can safely ignore the value. It is possible to use a _ pattern for that (which is not a variable binding, it's a pattern of its own, but this is probably where the underscore prefix convention comes from), but you might want to

I want to traverse a map using structure bindings, ignoring the key: for (auto& [unused, val] : my_map) do_something(val); I have tried different options with gcc-7.2.0: // The warning is issued for ([[maybe_unused]] auto& [unused, val] : my_map) do_something(val); // Syntax error for (auto& [[[maybe_unused]] unused, val] : my_map) do_something(val); // The same two combinations above with [[gnu::unused]]. It seems that the [[maybe_unused]] attribute is not implemented yet for structure bindings. Is there any simple solution to this? Any macro, gcc/gnu extension, or any pragma to temporarily