iso | Build pages and prototypes with Lab UI components | Frontend Framework library

The first quote is really saying the reference is not separable from the object.

... still seems to imply that "a reference is an object".

It really implies that a reference is a non-separable, non-first-class alias for an object, exactly as you first said.

The difficulty with these discussions is that the standardese meaning of "object" is already different from the meaning used in most less-formal contexts.

Let's start simple:

int a;

Would often be described as declaring an integer object a, right? It actually

1. declares an integer object
2. binds the name a to that object in the appropriate scope

Now, if we write

int &b = a;

we could say that b is the object in the same way as we could say that a is the object. Actually neither are correct, but given that informal text already uses the latter, it's no worse.

We should instead say that the name b refers to the same object as the name a. This is exactly consistent with calling it an alias, but informal or introductory texts would seem pretty cumbersome if they wrote "... the integer object referred to by the name a ..." everywhere instead of just "the integer a".

As for taking space in memory ... it depends. If I introduce 100 aliases for a single object inside a single function I'd be really surprised if the compiler didn't just collapse them (although of course they might still show up in debug symbols). No information is being lost here by eliding the redundant names.

If I pass an argument by reference to a non-inlined function, some actual information is being communicated, and that information must be stored somewhere.

One of the dependencies for python-docx is lxml. The latest stable version of lxml is 4.6.3, released on March 21, 2021. On PyPI there is no lxml wheel for 3.10, yet. So it try to compile from source and for that Microsoft Visual C++ 14.0 or greater is required, as stated in the error.

However you can manually install lxml, before install python-docx. Download and install unofficial binary from Gohlke Alternatively you can use pipwin to install it from Gohlke. Note there may still be problems with dependencies for lxml.

Of course, you can also downgrade to python3.9.

EDIT: As of 14 Dec 2021 the latest lxml version 4.7.1 supports python 3.10

The problem here is fundamentally that it's possible to write C programs containing errors (not just failures to achieve strict conformance) that it is not reasonable to demand a C compiler detect. At the time the standard was originally written (1989), whole-program analysis was out of the question, and even now, it's expensive. And one will always be able to gin up constructs like

Thanks to this comment on Reddit, I was able to figure the issue out:

1. find all the machines with docker-machine ls
2. remove the ones you don't need with docker-machine rm -y
3. find all the "host-only ethernet adapters" with VBoxManage list hostonlyifs
4. Remove the orphaned ones with VBoxManage hostonlyif remove
5. Create a vbox folder in the etc directory with sudo mkdir
6. Create a file networks.conf in the vbox folder, for example by sudo touch
7. place the below line there

Quick solution might be to pass reload as an optional parameter to setCurrency

Yes. The format of acceptable Date strings in JavaScript is standardized:

ECMAScript defines a string interchange format for date-times based upon a simplification of the ISO 8601 calendar date extended format. The format is as follows:

This program is well-formed and prints 1, as seen. Because S is defined identically in both translation units with external linkage, it is as if there is one definition of S ([basic.def.odr]/14) and thus only one enumeration type is defined. (In practice it is mangled based on the name S or S::x.)

This is just the same phenomenon as static local variables and lambdas being shared among the definitions of an inline function:

This looks like a constraint

I agree.

— why is it placed in the section "Semantics" (a violation of the requirement does not require a diagnostic) rather than in the section "Constraints"?

With regard to the parenthetical, I do not take the question of whether a diagnostic is required to be a key distinction between a language constraint and a semantic rule. A constraint is a

restriction, either syntactic or semantic, by which the exposition of language elements is to be interpreted

(C17, 3.8/1)

That's a mouthful, to be sure, but it comes down to constraints being rules for what code matching the C lexical grammar in fact conforms overall to the language specification, and what doesn't. As a consequence, adherence to language constraint can always be evaluated at translation time, and code failing to satisfy a language constraint effectively is not expressed in C. That is, constraints are rules applying to source code. This is the context for the requirement that implementations diagnose constraint violations.

Semantic rules, on the other hand, explain what C code means or what program behavior is associated, if any. These are rules for the runtime behavior of programs and C language implementations.

Which is all a long way back around to: I agree, despite being listed among the semantic rules, paragraph 6.9.2/3 is by nature a language constraint.

I doubt whether anyone will be able to respond with authority on why it is placed among the semantic rules, but it is perhaps relevant here that exactly the same wording appears as a semantic rule in every published version of the language specification, all the way back to C89, which positioned "incomplete types" a bit differently than C11 and later do.

It might be that the original ANSI C committee took a liberty here in order to excuse compilers from diagnosing this issue, perhaps because they saw an ambiguity in whether that restriction should apply to incomplete types that are completed later in the translation unit. I'm not sure about that myself, today. It's entirely possible that this represented a compromise position.

C11 Annex F says, in §F.1:

The IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for microprocessor systems, second edition (IEC 60559:1989) [...]

and then later, in §F.3, paragraph 1 (as you already quoted in the question):

The fegetround and fesetround functions in provide the facility to select among the IEC 60559 directed rounding modes represented by the rounding direction macros in (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the IEC 60559 directed rounding modes.

(Note: to be precise, I'm looking at the publicly available N1570 final draft for the C11 standard, but my understanding is that it's essentially identical to the final standard.)

So the reference to IEC 60559 here is actually a reference to the (now twice superseded) IEC 60559:1989 standard. I don't have access to that precise standard, but I do have a copy of IEEE 754-1985, and I believe that the content of those two standards (IEC 60559:1989 and IEEE 754-1985) is supposed to be essentially identical, though I observe that there are at least differences in capitalisation in the tables of contents of the respective standards. (Thanks to Michael Burr for confirming in a comment that the standards are identical in substance, if not word-for-word identical.)

IEEE 754-1985, in section 4, defines four rounding modes, which it terms "round to nearest", "round toward +∞", "round toward -∞", and "round toward zero". The latter three are described as "directed rounding modes". For "round to nearest" we have in §4.1 the text:

if the two nearest representable values are equally near, the one with its least significant bit zero shall be delivered

In other words, it's describing round-ties-to-even. (Later versions of the IEEE 754 standard introduce the names "roundTiesToEven", "roundTowardPositive", "roundTowardNegative" and "roundTowardZero" for the above rounding modes (now termed "attributes" rather than "modes", I believe because "mode" suggests some kind of persistent environmental setting), and define a fifth rounding attribute "roundTiesToAway". But C11 is explicit that it's referring to this earlier version of the standard.)

Now since C11 doesn't use the exact same terms as IEEE 754-1985, it's left to us to infer that the four rounding modes above correspond to "FE_TONEAREST", "FE_UPWARD", "FE_DOWNWARD" and "FE_TOWARDZERO", in that order, but there doesn't seem to be any reason to doubt that that's the intended matching. So assuming __STDC_IEC_559__ is defined, FE_TONEAREST should indeed correspond to "roundTiesToEven". Nate Eldredge's comment about C2x further reinforces that this is the intended matching.

So all in all, it's clear (to me at least) that the intent is that when __STDC_IEC_559__ is defined, the rounding mode FE_TONEAREST should correspond to "round to nearest", named in later versions of the IEEE 754 standard as "roundTiesToEven". The degree to which implementations of C honour that intent is, of course, a separate question (but I'd expect the vast majority of them to do so).