====== Bättre C ======

===== Bjarnis idéer =====
  * Mer flexibelt typsystem, så att man fritt kan ange egenskaper för typer istället för att vara bunden till en handfull fördefinierade typer som i C.
  * Inbyggt stöd för multiple precision-typer.
  * Enklare att skapa tillfälliga data som parametrar till funktionsanrop och sedan få dem automatiskt uppstädade efter anropet, i stil med hur det funkar i typiska skriptspråk.
  * Nån typ av enkelt arv för struktar kanske vore trevligt?
  * Möjlighet att ange i en deklaration var variabeln ska placeras i minnet, för att underlätta åtkomst av hårdvaruregister av olika slag utan att man behöver skapa pekare och dereferera dem eller använda länkskript för att ge variablerna adresser etc.
  * Något enkelt sätt att använda carryn vid addition/subtraktion.
  * Packning/uppackning, t.ex. för att ta två returvärden från en funktion: ''{foo, bar}=bazfunc();''
  * Eventuellt nån typ av tillfälligt-namespace-funktionalitet så att man slipper prefixa en massa namn med namnet på en struktvariabel i en bit av koden där man gör en massa saker med medlemmarna i samma struktvariabel.
  * Stöd för parallellisering, t.ex. så att man kan uttrycka addition av elementen i två arrayer utan att skriva det som en loop, och på så vis både göra koden enklare och underlätta för kompilatorn att optimera om det finns t.ex. SSE.
  * Nånting relaterat till teckenkodning som gör en glad.
  * Nästlade namnrymder för symboler? Kan användas till modulsystem, och kanske till sånt som nästlade funktioner...
  * Nästlade funktioner? :)
  * Anonyma funktioner?
  * ''do-while'' och ''while'' tycker jag ska vara samma sak: ''do stmt while(cond) stmt''
  * Ska vi ha nån sorts exceptions?
  * Ett stort fett standardbibliotek med alla tänkbara hjälpfunktioner, allihop med vettiga namn. Exempel på saker som passar i ett standarbibliotek: listor, stöd för funktionell programmering (map, zip, osv), dictionaries...
  * Gör brejsarna runt funktionskroppar till en del av kropparna, så att en funktionskropp blir ett normalt statement.
  * Hum, nån sorts iteratorer? Coroutines, generatorer?
  * ''sizeof(funktion)'' ska fungera.
  * Trevligt om man kan lägga till medlemmar i enums efter hand:

  struct instr{enum INSTR type; char *mnemonic;};
  
  struct instr instructions[]={
    {enum INSTR MOVE, "mov"},
    {enum INSTR ADD, "add"},
    {enum INSTR SUBTRACT, "sub"}
  };

===== Martins idéer =====
  * Ingen automatisk skräpsamling, inbyggd concurrency eller annat krafs. Körtidssystemet, om något alls behövs, ska vara enkelt. Meningen är att koden ska kunna köras på metallen precis som C.
  * Typer läses från vänster till höger, som allt annat: char *x[5] blir x *[5]char. Då är det lätt att läsa typen högt för sig själv: "x är en pekare (*) till en array med fem element ([5]) av typen char".
  * Typdefinitioner introducerar en ny typ på riktigt, inte bara ett alias. Explicita kast krävs mellan den nya typen och den underliggande typen.
  * Moduler/paket med inspiration från Python, Java, Erlang mfl. Bör gå att välja vilka symboler som exporteras ur paketet.