transmute | effective word list transmutation command-line app | Dictionary library

We may add some additional arguments in the function as input

1. colnm - column name that is used to subtract as string (ensym converts to symbol and it is evaluated with !! - by using ensym, we can also use unquoted argument as input)
2. pat - prefix pattern of the column name to be used for looping across those columns
3. cols_del - columns to be deleted. By default it is NULL. Thus, if we don't have the fourth argument, none of the columns are deleted.

Here is a base R way.

Disclaimer: I cannot judge whether the following approach is sensible in your concrete case, but I successfully employ it. I would only go the route if you e.g. profiled that using generics to exploit ZST actually improves performance, as this solution involves some maintenance.

• If you stay with struct Test, all users of Test will need to cope with the generic parameters A, B, C, D, too. Rust definitely allows you to do this, but in can become quite cumbersome to actually carry it out, as Rust basically requires the parameters at each and every affected function.

  Grouping all the generic parameters into a single one may mitigate the problem, but that also is no panacea (because of e.g. individual trait bounds).

• As for the run-time/compile-time dichotomy, the following problem arises: The number of combination of generic parameters grows exponentially, and you could in theory certainly check for all of these run-time combinations and convert each of them into the respective compile-time parameters, but that takes a lot of effort to write and maintain.

  However, I once wrote a macro cartesian_match, which can help you with this (assume you have a fn my_function(t: Test):

You can use model.matrix to create interaction terms. (This is what's done under the hood in most modeling functions.)

If all you want to do is read the contents of the Rust Vec without mutating, you need to use as_ptr:

There are too many issues in your code. We need to work from scratch. In general, here are some major concerns:

1. Don't do expensive operations so many times. Things like pivot_* and *_join are not cheap since they change the structure of the entire dataset. Don't use them so freely as if they come with no cost.

2. Do not repeat yourself. I saw filter(Id == idd, Category == ...) several times in your function. The rows that are filtered out won't come back. This is just a waste of computational power and makes your code unreadable.

3. Think carefully before you code. It seems that you want the regression results for multiple idd, date2 and Category. Then, should the function be designed to only take scalar inputs so that we can run it many times each involving several expensive data operations on a relatively large dataset, or should it be designed to take vector inputs, do fewer operations, and return them all at once? The answer to this question should be clear.

Now I will show you how I would approach this problem. The steps are

1. Find the relevant subset for each group of idd, dmda and CategoryChosse at once. We can use one or two joins to find the corresponding subset. Since we also need to calculate the median for each Week group, we would also want to find the corresponding dates that are in the same Week group for each dmda.

2. Pivot the data from wide to long, once and for all. Use row id to preserve row relationships. Call the column containing those "DRMXX" day and the column containing values value.

3. Find if trailing zeros exist for each row id. Use rev(cumsum(rev(x)) != 0) instead of a long and inefficient pipeline.

4. Compute the median-adjusted values by each group of "Id", "Category", ..., "day", and "Week". Doing things by group is natural and efficient in a long data format.

5. Aggregate the Week group. This follows directly from your code, while we will also filter out days that are smaller than the difference between each dmda and the corresponding date1 for each group.

6. Run lm for each group of Id, Category and dmda identified.

7. Use data.table for greater efficiency.

8. (Optional) Use a different median function rewritten in c++ since the one in base R (stats::median) is a bit slow (stats::median is a generic method considering various input types but we only need it to take numerics in this case). The median function is adapted from here.

Below shows the code that demonstrates the steps

Not sure if this exactly what you are looking for, but here is my attempt with rowwise and unnest

Yes, it is sound. In fact, the official documentation for transmute() says it can be used to extend lifetimes:

https://doc.rust-lang.org/stable/std/mem/fn.transmute.html#examples

Extending a lifetime, or shortening an invariant lifetime. This is advanced, very unsafe Rust!