eel | Extensible Embeddable Language for scripting in realtime | Database library

A single search considers only one scope—not an enclosing namespace or even a base class. It’s an unqualified search that considers all enclosing scopes. Single searches and (plain) searches are subroutines of these higher-level procedures.

It should be said, since there have been a lot of these questions lately, that these terms exist to reduce ambiguity and imprecision (e.g., CWG issue 191) in the definitions of “programmer-level” constructs like (un)qualified name lookup. I didn’t invent them to increase the number of vocabulary words that the typical programmer should be expected to have memorized. (Put differently, the standard is not a tutorial.)

Of course, there’s nothing special about this particular question in this regard, but I must hope that this will thereby tend to find the people that need to see it.

The ⟨library⟩ definition context tags were added when moving [definitions] from [library] (C++20) into [intro.defs] (current draft). The ⟨library⟩ definition context tag in the particular change you are quoting was added when [defns.prog.def.spec] in [definitions] (C++20 DIS) was moved into [intro.defs] as part of the following commit

[definitions] Integrate into [intro.defs]

Partially addresses ISO/CS 016 (C++20 DIS)

particularly adding the \defncontext{library} tag here.

These definition context tags have been present for a long time in [intro.defs], but as library definitions did not use to reside in [intro.defs], there were simply not any definitions in there for which ⟨library⟩ would be an appropriate definition context tag.

Nothing has changed. The relevant rule is now [class.member.lookup]/4:

Calculate the lookup set for N in each direct non-dependent ([temp.dep.type]) base class […]

so that there need not be a special override for the name-lookup rules in [temp].

forward_­iterator needs the semantic requirements of sentinel_for. Those are not implied by either regular or equality_comparable.

The missing pair issue in the example is just a bug with the example; I submitted an editorial pull request.

The bigger problem is with keys_view and values_view's definitions. An LWG issue has been submitted for which I have provided a proposed resolution. The basic issue here is that

This is a bug in both implementations. Both contain the equivalent of

The destructor of Bar has not finished, and therefore referring to a member of Bar, and indeed calling a member function of Bar within its destructor is OK.

Calling member functions of the super object can be a bit precarious though, since member functions may access sub objects, and some sub objects may have already been destroyed by the time the member function is called, and in that case accessing the destroyed objects would result in undefined behaviour. This is not the case in your example.

Or by "referring" standard means something particular?

I think it means to form a pointer or a reference to a sub object. As is done in the example below the rule.

Also, what does the phrase "after the destructor finishes" from the standard mean exactly? After the body of a destructor finishes? Or after all members and base classes destroyed?

The latter.

The body is executed first, then the destructor calls the sub object destructors, and then the destructor has finished.

The concept of a sentinel is closely linked to a iterator as it is known from other languages, which support to advance and test whether you reached the end. A good example would be a zero-terminated string where you stop when you reached \0 but do not know the size in advance.

My assumption is that modeling it as a std::forward_iterator is enough for the use cases where you would need to convert a C++20 iterator with a sentinel to call an older algorithm.

I also think it should be possible to provide a generic implementation that could detect cases where the iterator provides more functionality. It would complicate the implementation in the standard library, maybe that was the argument against it. In generic code, you could still detect the special cases yourself to avoid wrapping a random access iterator.

But to my understanding, if you deal with a performance critical code section, you should be careful with wrapping everything as a std::common_iterator unless it is needed. I would not be surprised if the underlying variant introduces some overhead.

This change was an inadvertent result of phrasing the rules more orthogonally, but since that orthogonality allows a few additional meaningful overload sets, there hasn’t been any hurry to “fix” it. In particular, it might work well with the proposal for deducing this that’s currently under consideration.