while it tedious, the compiler expect you to know what you are doing when you
mix different size of datatype, or when you use different datatype in an
operation.
consider this C code:
int a = 10;
int b = 3;
float c = a / b; /* compiler will allow this but beware that c = 3 and not
3.33333333 */
float d = (float) a / b; /* this time c = 3.3333 while perform hidden
conversion on b */
now in Nim:
var a = 10, b = 3
var c = a.float / b.float # no hidden conversion, you should know what you
are doing
# equals to c = `/`(a.float, b.float) because an operator is alias to
function call
I found this explicit conversion annoying when I write the code, but at the
same time, it force me to rethink the code I write, can I use less conversion
an thus make the code run faster?
Hidden conversion _could_ potentially hide bugs and cost performance too.
When reviewing other people's code or maintaining my own code, explicit
conversion help me to think more clearly.
btw, you could rewrite your template like this:
template volatileStore[T](dest: ptr T; val: SomeInteger) =
var dest[] = T(val) # do the conversion here, and get the convenience
when using this template
