Would Replacing LateInitializationError with LateInitializationException Be More Intuitive?

[Eglusaxie]

class Example {
late final String x;
}

main() {
Example example = Example();
try {
print(example);
} on LateInitializationError catch (e) {
x = "late init";
print(x);
}
}
This statement isn't working at the moment, but I feel like it should be allowed.

[julemand101]

Should not be allowed. It is an Error since they follow the definition of Error:

Error objects thrown in the case of a program failure.

An Error object represents a program failure that the programmer should have avoided.

Examples include calling a function with invalid arguments, or even with the wrong number of arguments, or calling it at a time when it is not allowed.

These are not errors that a caller should expect or catch — if they occur, the program is erroneous, and terminating the program may be the safest response.

When specifying late, you promise the compiler that you know what you are doing as a programmer, and the field will ALWAYS have a value when first time access the field. If you can't promise that, then your code are erroneous and should be terminated.

Exceptions are for situations which you can't predict like e.g. disk are full, bad network and so on. It should never be unexpected if a late field are being given a value or not.

If your program are unpredictable when it comes to fields being set or not, then those fields must be defined as nullable so you, as a programmer, are forced to check if the field contains a value before using it. This pattern are much more safe and prevents the errors you are trying to handle in your example.

[Eglusaxie]

Should not be allowed. It is an Error since they follow the definition of Error:

Error objects thrown in the case of a program failure.
An Error object represents a program failure that the programmer should have avoided.
Examples include calling a function with invalid arguments, or even with the wrong number of arguments, or calling it at a time when it is not allowed.
These are not errors that a caller should expect or catch — if they occur, the program is erroneous, and terminating the program may be the safest response.

When specifying late, you promise the compiler that you know what you are doing as a programmer, and the field will ALWAYS have a value when first time access the field. If you can't promise that, then your code are erroneous and should be terminated.

Exceptions are for situations which you can't predict like e.g. disk are full, bad network and so on. It should never be unexpected if a late field are being given a value or not.

If your program are unpredictable when it comes to fields being set or not, then those fields must be defined as nullable so you, as a programmer, are forced to check if the field contains a value before using it. This pattern are much more safe and prevents the errors you are trying to handle in your example.

Yes, now that I think about it, you're absolutely right.

[mateusfccp]

Not exactly what you are proposing, but #3680 would allow us to query for late variable initialization.

I think this would enable you to do what you want.