to-string | Converts Variables to strings | Runtime Evironment library

parenscript:ps is a macro, not a function: its body is literal parenscript and is not evaluated but compiled, from Parenscript to JavaSctipt. This is easy to check:

• You are using the wrong encoders for data, key and IV. All three are Base64 encoded (and not hex or Utf8). So apply the Base64 encoder.
• The ciphertext must be passed to CryptoJS.AES.decrypt() as a CipherParams object or alternatively Base64 encoded, which is implicitly converted to a CipherParams object.

When both are fixed, the plain text is: "[\"001\",\"001\"]".

Where did I do the wrong thing?

You need create a partial view which is a razor view instead of razor pages.

Email.cshtml:

No. A number stores no information about the representation it was entered as, or parsed from. It only relates to its mathematical value. Perhaps reconsider using a string after all.

If i had to guess, it would be that much of the confusion comes from the thought, that numbers, and their textual representations would either be the same thing, or at least tightly coupled, with some kind of bidirectional binding between them. This is not the case.

The representations like 0.1 and 0.10, which you enter in code, are only used to generate a number. They are convenient names, for what you intend to produce, not the resulting value. In this case, they are names for the same number. It has a lot of other aliases, like 0.100, 1e-1, or 10e-2. In the actual value, there is no contained information, about what or where it came from. The conversion is a one-way street.

When displaying a number as text, by default (Number.prototype.toString), javascript uses an algorithm to construct one of the possible representations from a number. This can only use what's available, the number value, also meaning it will produce the same results for two same numbers. This implies, that 0.1 and 0.10 will produce the same result.

Concerning the number¹ value, javascript uses IEEE754-2019 float64². When source code is being evaluated³, and a number literal is encountered, the engine will convert the mathematical value the literal represents to a 64bit value, according to IEEE754-2019. This means any information about the original representation in code is lost⁴.

There is another problem, which is somewhat unrelated to the main topic. Javascript used to have an octal notation, with a prefix of "0". This means, that 003 is being parsed as an octal, and would throw in strict-mode. Similarly, 010 === 8 (or an error in strict-mode), see Why JavaScript treats a number as octal if it has a leading zero

In conclusion, when trying to keep information about some representation for a number (including leading or trailing zeroes, whether it was written as decimal, hexadecimal, and so on), a number is not a good choice. For how to achieve some specific representation other than the default, which doesn't need access to the originally entered text (e.g. pad to some amount of digits), there are many other questions/articles, some of which were already linked.

[1]: Javascript also has BigInt, but while it uses a different format, the reasoning is completely analogous.

[2]: This is a simplification. Engines are allowed to use other formats internally (and do, e.g. to save space/time), as long as they are guaranteed to behave like an IEEE754-2019 float64 in any regard, when observed from javascript.

[3]: E.g. V8 would convert to bytecode earlier than evaluation, already exchanging the literal. The only relevant thing is, that the information is lost, before we could do anything with it.

[4]: Javascript gives the ability to operate on code itself (e.g. Function.prototype.toString), which i will not discuss here much. Parsing the code yourself, and storing the representation, is an option, but has nothing to do with how number works (you would be operating on code, a string). Also, i don't immediately see any sane reason to do so, over alternatives.

Scope based lookup starting from the body of TestHandlerT::from_string hits the member function before it hits lib::from_string. So just reintroduce lib::from_string into the scope of the body with using. This also reenables ADL, as ADL is suppressed when scope based lookup hits a class member.

Here you are:

You can't get TypeScript to infer something that's in direct contradiction to what it's been told explicitly (Readonly>). That type annotation wins the day.

The fix is, as you've indicated, to remove the type annotation. But you've said you can't do that.

Since you can't remove the type annotation — e.g., the array is defined by code you don't control — then you have no choice but to duplicate the list of possible values in the type, which leaves you open to maintenance issues when the original changes and you don't update the duplicate. To mitigate that, you can add a runtime check to handle the case where the original is changed so they no longer match:

The original string needs to be split to multiple codepoint strings. The resulting strings can then be converted to integers:

is returning the string_view this way unsafe (or UB) in any way, or can I keep on doing this with good conscience?

Yes. The way you use it is perfectly ok. The string_view returned by your toString function forms a view on data that will remain intact until the program terminates.

Alternatively, is there a better (faster/safer) way of solving this general problem of enum-to-string?

You could make a constexpr function with a switch-statement inside it, like so: