ITT we plan for C 2017 standard, what would you like added to the one above all programming language?

ITT we plan for C 2017 standard, what would you like added to the one above all programming language?

>namespaces
>void function return aka return Foo();

Make it interpreted and not compiled

end ur life fucking pajeet

That has nothing to do with a standard
You're retarded

Php will rule them all.

Just give some sort of standard array type with bound checking and that's it.

>nothing to do with standard
Got myself a catch checkmate

As optional add basic datastructure to the standard library. People have change to implement their own but at least they could follow the standardized API.
Lambda functions.
Optional socket and directory handlign API.
Better macrosystem that supports recursive macros.
Maybe optional header for dynamically loading libraries.
Able to call function that's defined in the compilation unit even if the prototype is not declared before the function.
Header for simple basic type which has stuff like u8, u16 and so on. It's fucking retarded that every faggot has to define those for their own project.

And if we go crazy
type inference
Some kind of block for defining overloaded functions like
overload prefix_myfn {
/* void prefix_myfn_void_intp_intp(int*, int*); */
void(int *x, int *y) { int tmp = *x; *x = *y; *y = tmp; }
/* void prefix_myfn_int_intp_intp(int*, int*); */
int(int *x, int *y) { int tmp = *x; *x = *y; *y = tmp; return tmp; }
}
int tmp0 = 10; int tmp1 = 20;
/* knows which function prototype to use */
int x = prefix_myfn(&tmp0, &tmp1);

That last idea sounds great. Would remove overhead of size member in structs.

they should have a better system than includes. something that is better at handling dependencies. I shouldn't have to include all of stdio.h but rather just use the functions I need.

Already exists and has nothing to do with the standard.

>Better macrosystem that supports recursive macros.
How the hell would this work?

This is the gayest idea ever. We don't need more JavaScript faggots in the world.

Namespaces, classes, templates, a standard library, function overloading.

Less fucking undefined behavior

A vector datatype that resizes itself

Someone do the C++ version.

so you want the #

Since C99 it's already illegal to call functions without declared signatures. Why couldn't we get rid of code bloat like this:
static void spinCamera(void);
static void followHeroWithCamera(void);
static void moveHero(void);
static void applyGravity(void);
static void applyJump(void);
static void jump(void);
static void adjustPipeline(void);
static void doCollision(void);
static void doLevelBoundsCollision(void);
static void doStaticCollision(void);
static void doDynamicCollision(void);
static void resolveCollision(const DgPen2D *pen);
static void addPenetrationToHeroPosition(const DgPen2D *pen);
static void maximizePenetration(const DgPen2D *a, const DgPen2D *b, DgPen2D *max);
static void doDynamicHeroArrayCollision(DgPen2D *pen);
static void doDynamicHeroCollision(size_t i, DgPen2D *pen);
static void doDynamicShrinkerArrayCollision(DgPen2D *pen);
static void doDynamicShrinkerCollision(size_t i, DgPen2D *pen);
static void doDynamicPulsatorArrayCollision(DgPen2D *pen);
static void doDynamicPulsatorCollision(size_t i, DgPen2D *pen);
static void activateEjectors(void);
static void activateEjector(size_t i);
static void eject(void);
static void activateShrinkers(void);
static void activateShrinker(size_t i);
static void makeShrinkerShrink(size_t i);
static void shrinkShrinkers(void);
static void shrinkShrinker(size_t i);
static bool penetratedAsFloor(const DgPen2D *pen);
static void collectCoins(void);
static void collectCoin(size_t i);
static void takeCoin(size_t i);
static void collectGravitons(void);
static void collectGraviton(size_t i);
static void takeGraviton(size_t i);
static float calcPulsatorSize(size_t i);
static bool switchHeroesIfNeeded(void);
static bool heroIsReadyToSwitch(void);
static bool heroIsNearShrinkers(void);
static bool heroIsNearShrinker(size_t i);
static bool heroIsNearPulsators(void);
static bool heroIsNearPulsator(size_t i);
...
and just let the compiler extract the signatures from the file beforehand?

>basic type stuff
This is already in C99.
>overloading
_Generic

Stuff like uint32_t yes, but everybody still typedefs it to u32 which is fucking retarded.
_Generic only works with macros and you can't use it if you want to define function that can be found from the compilation unit.

Inheritance and polymorphism plus overloading is the right answer.