What is your language feature wish list?

[PIEBALDconsult]

I make a static Hashset for that (C#).

[tronderen]

Is that really a language feature? I suppose it could be useful, but it sounds more like a library/OS feature.

[Single Step Debugger]

That's cool. The build-in contains/subset functions are native and fast.

Advertise here – minimum three posts per day are guaranteed.

[tronderen]

Well, yes, but ... In all the Pascals I have been in touch with, it is implemented as a bit map. A few orders of magnitude lighter, I guess. There are several other Pascal features I certainly would welcome in C#. Such as decent enumerations, as a first class data type - not just symbolic names for integers, that cannot even be used as integers! In particular: The enum we are offered cannot even be used as an array index type. Closely related: I would welcome Pascal style subrange types. Define a type Year = 1900..2050, and assigning a value outside this range to a variable of type Year is caught by the runtime system (or the compiler, if it can be determined statically). Related to this: An array with index type Year, so valid index values run from 1900 to 2050. To go a little beyond Pascal: I wish we had a mechanism for defining incompatible types: If I could define 'new type Speed = float;' and 'new type Volume = float;', variables of type Speed and Volume would be incompatible, and the compiler would give an error if you try to add them (without a proper operator definition for the two types, or an explicit cast).

[Niels Holst]

There are setwd(path) and getwd(path) functions for setting the working directory (i.e. the folder from which any relative path would be rooted) but there is no way of finding out from where a script was loaded. That makes it cumbersome to distribute R scripts as an assemblage (e.g. a zip file) of interconnected R scripts and data files. The user must be instructed to call setwd(path) in the beginning of the main script with the folder of her choice. The same goes for yourself when you move your assemblage of R files from one folder to another; you always need to update the setwd(path) statement as well.

[PIEBALDconsult]

Oh, well, yeah, for individual (ASCII) characters a bitmap or similar may be best. I was thinking of a more general technique.   Edit: As in making a Hashset and putting various (UNICODE) quote characters or whitespace characters in it to test against. Yes, there are many things Pascal does which are handy. But I haven't used Pascal in decades, not since learning C.

[tronderen]

Loop enhancements: First iteration statements executed in loop context. An optional 'break code' added to a 'break', to indicate why a loop is prematurely terminated 'Handlers' that executes in the context of the loop, for each break code. 'finally', like in exception handling. E.g.:

for (record r = head; r; r = r.next) {

initloop: {
int iterationCount = 0;
record trailer = null;
int accumulated = 0;
}
...
if (++iterationCount > limit) break : GivingUp;
...
if (r.key == desiredKey) break : RecordFound;
...
trailer = r;
accumulated += r.value;

exitbreak (GivingUp): {
Console.WriteLine("Possible circular list: " + head.listname;
Console.WriteLine("Giving up after " + iterationCount + " iterations");
}

exitbreak (RecordFound): { // process r, with access to loop local variables, e.g.
if (trailer == null) head = r.next;
else trailer.next = r.next;
r.sumOfPreceding = accumulated;
// save r on disk
}

exitloop: {
Console.Writeline(desiredKey + " not found among " + iterationCount + " records");
}

finally: {
}
}

This would keep all the action related to the loop as one syntactical unit. It would reduce variable clutter for reporting the loop termination, and termination actions would have access to variables relevant to the loop alone. The above actions, expressed without these enhancements, would require a handful of (loop) global variables, and the semantics would be spread out before the loop, in the loop and after the loop, not as one syntactical unit. Alternately, the loop body would have several if/else levels of nesting and it would be difficult to identify the exit actions as such.

[tronderen]

Pascal had bitmaps as a first class type ('SET OF'), with operations for inserting and removing elements, intersection / union / difference operators and membership tests. I guess that the C code I have written for doing the same things were at least as efficient as the Pascal compiler could have done it (it probably would have added a lot of range tests), but I certainly have often missed the syntactic simplicity of Pascal for such operations!

[tronderen]

Sure, I see the usefulness. But I see it as a library extension, not as a language extension.

[Niels Holst]

Oh, now I get it. You are right.

[BernardIE5317]

switch( x, y, z )
{
case 1, 2, 3:
break;
etc.
}

[Jeremy Falcon]

Cpichols wrote:

I do wish that JavaScript could handle associative arrays (not objects) in foreach loops where keys and values could be easily accessed for each item in the array

Most times people blame the language when it's really due to them not studying the language.

const data = [];

data['a'] = 200;
data['b'] = 300;

for (const datum in data) {
console.info(`${datum}: ${data[datum]}`);
}

Cpichols wrote:

and so that it could be done recursively

No language I've ever used does recursive traversing of objects automatically in a loop. Why would JavaScript be more difficult to understand?

Jeremy Falcon

[User 13269747]

C:* defer that works just like Go's defer

• Anonymous functions that don't mark the stack executable[1], so that defer is actually useful.
• Replace #define with lisp-like macros (now in Nim as well, I believe)
  Lots more, just don't have the time. [1] Current methods to do nested functions using compiler-specific extensions mark the entire stack as executable.

[tronderen]

CHILL has that. Or maybe I should say "had" - I don't know if anyone at all are using CHILL nowadays. We (i.e. Norway) used to have half of our land line phones handled by switches programmed in CHILL (ITT System 12 switches) but the land line phone system was closed down last newyear. Now only mobile phones and IP phones are left. Maybe CHILL is where you take your proposal from. You present a simplified view: CHILL offered both '*' for Don't Care and ELSE for All other values than those mentioned explicitly in other switch alternatives. CHILL has a few other properties that goes into my language feature wish list. It is a pity that it never caught on as a general language, it is really well designed. But noone worked for it - not even the creators of the language (The initial C is for CCITT, 'CCITT HIgh Level Language'. CCITT changed name to ITU-T many years ago.). They saw it as a good language for programming phone switches, and didn't care to consider the language for any other use.

[englebart]

Convert it to a function In(var1, param1,…) Or throw some functor at it like In(var1)(param1,… ) Is(var1).in(param1…) Could be a lot slower, though.

[englebart]

I am rusty in C/C++, but thought typedef would do that for you in C and C++. Need a cast to assign between the typedefs even if they are both native float.

[englebart]

Java really needs typedef. It could easily be restricted to final classes. Implement it via erasure like other Java generics. typedef String InvoiceId;

[Chad3F]

C: - A standard (and simple) way to declare a parameter (or local variable) as not-nullable. Clang supports such an extension, as does gcc (but in a less clean way). It would be better to have a portable tag to do it defined in the language standards. Honestly, this should have been done in back in C99, and would have probably stopped many bugs over the last decade or two. - Variable value bound declarations. So if a parameter is declared unsigned int, but really only has a meaningful range of 0-100, it could flag it during compile time that it is an error. Probably more useful to set reasonable bounds on items which could cause integer overflows (or static buffer overflows when still used due to legacy code).. For example:

typedef struct
{
int id;
char name[20];
} myrecord_t;

myrecord_t * alloc_list(__bound__(0, 10000000) unsigned int size)
{
/* size > 178956970 on 32-bit ===> overflow */
return malloc(size * sizeof(myrecord_t));
}

void safecaller(__bound__(1, 100000) unsigned int size)
{
/* Okay - [1-1000000] with-in [0, 10000000] bounds */
myrecord_t * list = alloc_list(size);

/* ... */
}

void badcaller(unsigned int size)
{
/* Compile ERROR - default (32-bit) unsigned int not with-in [0, 10000000] bounds */
myrecord_t * list = alloc_list(size);

/* ... */
}