Things to look up in the docs

[bearophile]

In a language like C/D1 there are common simple parts that's easy to remember, like:
int x = 10;

Other parts are more complex, but they are common enough that you usually remember them:
for (int x = 10; x < foo.bar(); x += 2) {}

Other parts of the language or its standard library are less easy to remember, but in normal programs they are uncommon enough that looking them into the docs is acceptable. You don't need to keep in memory all the standard library of Java or C# to use such languages.

But in a language (like D1/D2) there can be parts that are both common enough and hard enough to remember, those are a problem, because looking in the docs each time is a waste of programming time (especially if you don't have an IDE under your hands) and more. Realistically it may be impossible to remove or simplify all such parts from a large system language as D1/D2, but it's important to write down a list of such parts, to keep such list in memory during the language design, and to try to minimize the length of such list. In theory some of the things in such list can be modified to make them more easy to remember, etc.

It's nice to program in Python also because most common parts of the language are easy to remember, for example the are't one undred string/list methods as in Ruby, so after few months you memorize the most common Python string methods, and this helps speed up programming significantly. 

What are the parts of the D1/D2 languages that are both common enough in programs and not easy to remember, so you need to look them often in the docs (or in an example list, code snippets list, already written code, etc)? This list is partially subjective, but probably there are also some common trends.

For example the syntax of opApply is one of the things I have often to look up in the docs (while I never need the manual to remember how to write a generator in Python, that has very similar purposes).

Do you have other parts to add to this list?

Bye,
bearophile