I can’t speak for the language designers, but from what I can reason on, it seems like it was intentional, proper design decision. Looking at this basic F# code, you can compile this into a working library. This is legal code for F#, and only overloads the equality operator, not the inequality: module Module1 type … Read more
I’m more interested with the reason/logic for why it was restricted. just for curiosity. If you read the C# Language Spec, 10.11.3, it hints as to the rationale here. In discussing variable initializers: It is useful to think of instance variable initializers and constructor initializers as statements that are automatically inserted before the constructor-body. Since … Read more
There seems to be two reasons for a class to be “final” in Python. 1. Violation of Class Invariant Classes that follow Singleton pattern have an invariant that there’s a limited (pre-determined) number of instances. Any violation of this invariant in a subclass will be inconsistent with the class’ intent, and would not work correctly. … Read more
The modern operating systems we have (Windows, Linux) operate with what I call the “big stack model”. And that model is wrong, sometimes, and motivates the need for “stackless” languages. The “big stack model” assumes that a compiled program will allocate “stack frames” for function calls in a contiguous region of memory, using machine instructions … Read more
The compiler code suggests that this is by design, though I don’t know what the official reasoning behind that is. I’m also not sure how much effort it would take to reliably implement this functionality, but there are definitely some limitations in the way that things are currently done. Though my knowledge of the PHP … Read more
History What problems would arise if arrays became a generic type? Back in C# 1.0 they copied the concept of arrays mainly from Java. Generics did not exist back then, but the creators thought they were smart and copied the broken covariant array semantics that Java arrays have. This means that you can pull off … Read more
Yuval and David’s answers are basically correct; summing up: Use of an unassigned local variable is a likely bug, and this can be detected by the compiler at low cost. Use of an unassigned field or array element is less likely a bug, and it is harder to detect the condition in the compiler. Therefore … Read more
I think one reason it works this way is because access modifiers work at compile time. As such, determining whether or not a given object is also the current object isn’t easy to do. For example, consider this code: public class Foo { private int bar; public void Baz(Foo other) { other.bar = 2; } … Read more
This question is, to some degree, related to What is the reason why “synchronized” is not allowed in Java 8 interface methods? The key thing to understand about default methods is that the primary design goal is interface evolution, not “turn interfaces into (mediocre) traits”. While there’s some overlap between the two, and we tried … Read more
The alternative would be quite heavyweight — storing “default argument values” in the function object as “thunks” of code to be executed over and over again every time the function is called without a specified value for that argument — and would make it much harder to get early binding (binding at def time), which … Read more