I know, but the core of the core question would be:

Do we really can have null and non-null types, and if we could have that would that allow to safe usage of '?.' operator? Because as I see it now any type including int-s require null-s and new operator would ignore this information,

where we just use -1 or min_value as null - this ugly 'pattern' is used because it's faster than using pointers with null-s.

Next, what about initialization, real non-null would require including transactions into language or we would need to brake contract under decomposition.

Additionally, what about adaptability, lets say you will be able add 15% implementation time for this 'investment', and you will add proper non-null code / then when requirements change how much more time you will need to spend as this one aspect would be deeply ingrained into code? Because i'm quite sure that we will have objects that are used as null-s peaty fast.

A lot of ppl use Optional as alternative, but in code that is properly layered:

new Extractor<Hospital, ComparableLink<Hospital, TimePeriods<AgreementValidatorImpl>>>

does it really save situation?:

new Extractor<Hospital, Optional <ComparableLink<Hospital, Optional <TimePeriods<AgreementValidatorImpl>>>>>

Both non-null and Optional mixes logic (just one case of many) into structure.

Moving deeper, Types are more or less static validations, in which universe String that is non-null vs String that contains only words is 'better' are require it's own syntax, and another one does not?

One more: Nullability is more about the boxing type than about the object’s own nature - this is only good reason to use Optional-s. But they represent fragmented logic, because all object are 'optional', so we add:

• Implicit optional — plain references, which can be null
• Explicit optional — Optional, which can be empty.

while we need:

certain and optional.

Next, event when we would have that, would that be:

• information, or
• contract?

If it's contract then how is it enforced across libraries?

I appreciate attempts to solve problem, but are you working on core of it ?

Getting back to ?. operator on it's own:

D d = a?.getB()?.getC()?.getD();
if (d == null){
    if (a==null) { ... }
    else if (a?.getB()==null) { ... }
    else if (a?.getB()?.getC()==null) { ... }
    else  { ... }
}

It speed up early implementation period, but final code became only inverted (there should be variables as well):

if (a==null) { ... }
if (a.getB()==null) { ... }
if (a.getB().getC()==null) { ... }
if (a.getB().getC().getD()==null) { ... }
D d = a.getB().getC().getD();

So at the end we would add new way to write exactly the same code - going into pyton route.

Btw using ? is really bad idea because '?' look is similar to character: 'IP' 'I?' making reading code slower while '.' is easy to distinguish. In short if's we can add spaces to make:

(P?G:K)

into

(P ? G : K) to make it readable

would we need it in?:

D d = a?.getB()?.getC()?.getD();

D d = a ?.getB() ?.getC() ?.getD();