Hacker News Reader

Comment by jeltz | Hacker News Reader

Not it is not. They mean different things.

    String? a = null;
    String b = null;
    String? c = "";
    String d = "";
    String! aa = a; // Compilation error
    String! bb = b; // Runtime error
    String! cc = c; // Compilation error
    String! dd = d; // Works!

View on HN

Thanks for clarifying the distinction - that's worse than I thought. When an expression as simple as bb = b can throw something has definitely gone wrong.

It has nothing to do with the expression’s simplicity. There are rules uphold by the compiler, and those are displayed in the easiest example possible. There may be additional rules that could show a warning in these cases (e.g. java can track whether a variable gets initialized in both branches and similar quite well), but that’s besides the point. Take these examples in a way that the only thing you know about variable `a` is its type.

These are stupid rules. The point of the proposal is to invite discussion on the proposed rules. Introducing implicit type conversions that throw to a language which is otherwise strongly typed is an awful idea.

Java should take a look at its own history and how it was able to retrofit generics into the language. It's nearly all type safe and the unfortunate unsafe parts generate compiler warnings.

How is it not type or null safe? It’s as safe as it can be.

And that is why you want to migrate everything to T? and T!.

Reply on news.ycombinator.com