language-design

Suppose you are using the ternary operator, or the null coalescing operator, or nested if-else statements to choose assignment to an object. Now suppose that within the conditional statement, you have the evaluation of an expensive or volatile operation, requiring that you put the result into a temporary variable, capturing its state, so that it can be compared, and then potentially assigned. How would a language, such as C#, for consideration, implement a new logic operator to handle this case? Should it? Are there existing ways to handle this case in C#? Other languages? Some cases of

Would it make sense to have a " constify " operation in C/C++ that makes a variable const ? Here is an example where it could be useful, where obviously we don't want to declare it const yet in the first line: std::vector<int> v; v.push_back(5); constify v; // now it's const Currently, without such a possibility, you'd have to introduce another variable to get the same effect: std::vector<int> v0; v0.push_back(5); const std::vector<int>& v = v0; That's more confusing since it adds a new name into the scope and you need to make it a reference to avoid copying the whole vector (or use swap ?).

A colleague said he heard of a language that did not have the concept of "if". Is that possible? If so, what language is it? Besides perhaps Prolog, I don't know of any specific languages, but I can think of a few ways a language without if statements may work. In fact, you don't need loop constructs either. You obviously needs some way of conditional branches and looping. If, for example, you had the following features: functions , ML-style pattern matching on function arguments and tail-call optimization , you could program without if's or loops. foo () { for (i = 1 to 10) { if even(i) {

Reading the basic introduction : If you try to use a subscript that is not in the array, you will get an error: array access is bounds-checked at run-time. Why does Rust check array bounds at runtime, when it seems most other checks occur at compile time? Because checking indices at compile time is not feasible in the general case. Reasoning about the possible values of arbitrary variables is somewhere between hard and impossible even for small programs. Nobody wants to have to: formally prove that the index can't be out of bounds, and encode that proof into the type system ... for every

In Ruby, super is a keyword rather than a method. Why was it designed this way? Ruby's design tends toward implementing as much as possible as methods; keywords are usually reserved for language features that have their own grammar rules. super , however, looks and acts like a method call. (I know it would be cumbersome to implement super in pure Ruby, since it would have to parse the method name out of caller , or use a trace_func . This alone wouldn't prevent it from being a method, because plenty of Kernel 's methods are not implemented in pure Ruby.) It behaves a little differently, in