transmute | The Transmute Command | Cryptocurrency library

You can't normally transmute between different structures just because they seem to have the same fields in the same order, because the compiler might change that. You can avoid the risk by forcing the memory layout but you're then fighting the compiler and preventing optimizations. This approach isn't usually recommended and is, in my opinion, not needed here.

What you want is to have

• a recursive data structure with public fields so that you can easily build it
• an identical structure, built from the first one but with no public access and only built after validation of the first one

And you want to avoid useless copies for performance reasons.

What I suggest is to have a wrapper class. This makes sense because wrapping a struct in another one is totally costless in Rust.

You could thus have

You can avoid the deprecated std::mem::uninitialized() function by following the recipe from MaybeUninit documentation.

As you discovered, you'll need to switch from the scary transmute to the even scarier transmute_copy due to (what's likely) a compiler issue. In this case transmute_copy() is sound because you're transmuting MaybeUninits (which are not dropped) and which you're not touching after the transmute.

There are a few issues you need to consider here:

• seq() is not vectorised over from and to, so it will require that StartDate and EndDate are length 1. You can achieve this by using rowwise()
• The replacement columns will have type date, so you will not be able to simply include zeros, as these will be coerced to 1970-01-01 (try lubridate::as_date(0)). The best alternative is probably to use NA here.
• transmute() will drop the columns being used, i.e. it will drop StartDate and EndDate. If you want to keep them you should use mutate() instead
• The main issue in your example is that your .funs argument is not a function. From the documentation:

A function fun, a quosure style lambda ~ fun(.) or a list of either form.

• Scoped verbs, i.e. functions ending with _at, _if etc are superseded in favour of across() as of {dplyr} 1.0.0.

Here is an example that takes the above into account:

1. head works:

try this

I think this will work:

I think CowStr is a Cow with 'static lifetime otherwise it'd be hard or impossible to store strs inside the map.

Well yes and no, you can store &'static str inside a hashmap with no issue, the problem is that you can't store both &'static str and String.

Am I rigth? If so, why simply not use String, so we can get rid of lifetimes and thus transmute?

I assume that is an optimisation: with String you'd have to create an allocation every time you want to insert a challenge in the map, but if the overwhelming majority of challenge names would be Digest and Basic then that's a waste of time (and memory but mostly time), but at the same time you'd have to support String for custom auth schemes.

Now maybe in the grand scheme of things this is not an optimisation which actually matter and it'd be better off not doing that, I couldn't tell you.

I don't like unsafe, and reading about transmute it looks very unsafe.

It's a debatable thing to do, but in this case it's "safe", in the sense that the reference is valid for the entirety of the HashMap::get call and we know that that call doesn't keep the reference alive (it's reliance on an implementation detail which is a bit risky, but the odds that that would change are basically nil as it wouldn't make much sense).

Extending lifetimes is not in-and-of-itself UB (the mem::transmute documentation literally provides an example doing that), but requires care as you must avoid it causing UBs (the most likely being a dangling reference).

It took me a bit to decompose your code, but up front, here's the smaller (and faster) code:

*const () is very similar to C's const* void indeed, except for the fact that () represents exactly one value, while void represents no values. Relevant answer about difference between () and void

If so, why doesn't it support pointing to the floating-point numbers?

It does, it's just that foo as *const () has nothing to do with pointing to a float, it has to do with taking a value and converting it to a pointer with the same numeric value, which doesn't make sense for floats.