Re: [boost] [endian] [bikeshed] Conversion function naming discussion

On Mon, Jan 26, 2015 at 5:09 AM, Rob Stewart wrote:

On January 25, 2015 9:06:17 AM EST, Beman Dawes wrote:

...

big_to_native big_to_native_inplace native_to_big native_to_big_inplace little_to_native little_to_native_inplace native_to_little native_to_little_inplace conditional_reverse conditional_reverse_inplace

These are quite explicit, but are a bit too long and awkward for my taste. I'd be willing to change these names if someone can come up with replacements that are shorter and less awkward, but still reasonable explicit.

One option is to use "_copy" for the first set and remove "_inplace" for the others.

I generally like "to" rather than "from" in names, but the types are usually distinct, so that doesn't work so well here. Peter's "from_big", et al, aren't bad, but not great, from that perspective, but don't distinguish between little and native as the target order.

In general, I actually like "from" better than "to", as it typically (although not in the endian case) solves a problem of param order: foo_to_bar(a, b); // which is the foo a or b? ie strcpy order (dst,src) or function-name order (foo,bar)? foo_from_bar(a, b); // a is the foo. function-name order AND strcpy order. (note: Stepanov admitted he got std::copy() in the wrong order and should have matched strcpy() and assignment - destination on the left). But anyhow, in this case we only have a single arg, so not exactly the same situation. Other common words used for this are "as" and "make" (the std uses "make" a lot, I think there are proposals for "as" - which are for cast-like situations) int x = as_little(y); int x = make_little(y); Not sure those are any better. I would say "make" would actually be a good term for the in-place version (ie alter this thing to make it little) if only the standard didn't already use it everywhere with a return value. :-( But maybe in-place could use different terms, replacing the "to/from" with uh, something? ie bigify(x); unbiggen(x); Another alternative: use 'native' for the inplace versions x = from_little(y); x = to_little(y); native_to_little(y); // in place Probably not as clear as the other choices. :-( Basically, I don't like any of them because I don't like that the input's big vs little is not part of the type system (ie use the arithmetic endian types), and is instead part of the function name ie I'd prefer int x = to_native(assume_big(y)); // assume_big casts y to a big int type, without altering the bits, then to_native knows what to do that could probably just be int x = assume_big(y); or int x = assume_cast<big>(y); because once assume_big returns a big_int32 then the int conversion is already there. Anyhow, - I could live with the original long names (how often are they used? Won't it only be in isolated code?) - I could live with Peter's shortened names Tony