tidy | Tidy up your data with JavaScript , inspired by dplyr | Data Visualization library

We may extract the numbers with str_extract_all in a list and unnest

There is no variation across id/model, in terms of .value/test_value, so the output is the same for each iteration. However, presumably your actual data has this variation. Below is an approach that groups by id and model (i.e. 12 groups), and then uses nest(), map() , and unnest_wider() to get your result

You can't just pass in a string. A string is not the same as an expression. One way is to use purrr and rlang to build the expression and then inject that into the select

I found the issue. On a hunch, I investigated the whitespace.

If the column names are the same, we may loop across the columns of 'tidyX' and use the column name (cur_column()) to extract the corresponding column of 'coefs'. But, here the column name is different, so use match to get the column index, extract ([[) the column/element (if it is a named vector) from 'coefs' and multiply

Yes, it correct to say the modules really "used" by the application are listed by go list -m all (as per documentation you provided the link of). By "used", it means the package selected at build time for the compilation of the go code of your application.

We had a similar issue with a static analysis tool and we had to change the configuration to use the output of go list -m all (dumped in a file) instead of go.sum.

Constructors can have side-effects beyond constructing the new object. The semantics of the two versions could therefore differ.

Even if that is not the case, the compiler might not be able to determine that during compilation. For example if the copy constructor of the foo type is not defined in the same translation unit and no link-time optimization is used, the compiler wouldn't be able to optimize away the copy, since it might have side-effects that are unknown at compilation time of the current translation unit.

Similarly the loop body might call functions for which the compiler cannot prove that they don't modify foo, in which case the copy can also not be optimized away.

(This is by the way harder for the compiler to prove than it is for clang-tidy to give you the warning, since even a function taking a const reference of foo is technically still allowed to modify it. And even if the foo object itself is const-qualified (e.g. const auto), functions may depend on the address of the foo object being different than that of the container's foo object through other program paths.)

Even if everything is visible in the translation unit and the observable behavior doesn't depend on the copy, the operations might be too complex for the compiler to optimize the copy away.

Example:

You can use runresult, provided you are happy to pass the procedure's argument as a string:

We may use select