<-- back

Things to throw away or replace

Remember, NAL shall be "transcodable" to C, therefore in this section, we show how things in NAL can be converted to C if removed or replaced.

Arrow operator `->`

Compilers know the type of a value when transcoding to C and hence can automatically decide whether it is a pointer or not. No need to have two separate operators -> and . therefore. To make code look like other programming languages, we favor the dot operator.

Discussion

Maybe add ~> (Tilde-Pointer) for backwards combatibility for crazy people still wanting to have unsecure pointer.

`short`, `long`, `int`, `signed`, `unsigned`

The type int and its modifiers short and long are system dependent. Additionally, the modifiers signed and unsigned are just cumbersome. We replace this all with built-in types:


    NAL:
    i8
    i16
    i32
    i64
    ...


    C:
    int8_t
    int16_t
    int32_t
    int64_t
    ...


    NAL:
    u8
    u16
    u32
    u64
    ...


    C:
    uint8_t
    uint16_t
    uint32_t
    uint64_t
    ...

`char`

In C, the type char has the semantics of storing one character. That is usually 1 Byte but not necessary, therefore system dependent. Additionally, char is accessible as a number which is semantically wrong. We replace the type with the following.


    NAL:
    letter


    C:
    char

A letter is encoded in UTF-8. It is not accessible as a number, unless one uses converter methods like myLetter.ToASCIINum().

Discussion

Instead of letter, how about glyph?

`float`, `double` and `long double`

We replace the floating point types of C with the following:


    C:
    float
    double
    long double (if available as 128 bit)

And we allow for newer floating point types like f16 (which would correspond to the IEEE-754 half type) or f128 (which would correspond to the IEEE-754 quad type)

Discussion

Originaly, the proposal to use single and double was given but was quickly abandoned.

Operators `++` and `--`

After discussion, all ++ and -- operators shall be deleted. There is little to gain from it.

Original discussion:

There is a prefix and postfix variant of both ++ and --. The postfix variant has the semantics of changing the value AFTER its access. We do not allow for these variants anymore.

Discussion

Why not removing all Increment and Decrement operators. i += 1 is not hard to write or even i = i + 1.
Postfix operators are used favourably with pointer arithmetics. As we can not allow pointer arithmetics anymore, there is one more reason to let go.
It is not hard for a programmer to rewrite a line of code such that a postfix operator is not necessary anymore.
In C++, the postfix operator usually is also frowned upon as it complicates operator overloading.
++ and -- is often used in C for the for loop. But as we change the for loop anyway, there is one less reason to have these operators.

Underscore `_` as a symbol character

Discarded.

Idea was to disallow the underscore _ as a character in symbol names. Was smiled at by a few but frowned upon my many and overal.

Discussion

People get angry when it comes to naming conventions.
snake_case is debatably easier to read than camelCase.
m_member would not be possible anymore.
SCREAMING_SNAKE_CASE would not be possible anymore.
There would basically only be two case possibilies to distinguish: lowerCamelCase and UpperCamelCase.

`do-while`

Replace do-while with a new keyword until. Put condition before {} Block. This needs a new thinking bucause the condition is inverted. But it is more intuitive and corresponds more closely to the semantic such a loop represents.


    NAL:
    until(condition) {
      ...
    }


    C:
    do {
      ...
    } while (!condition)

Discussion

Original idea was to remove do-while completely without replacement.
Other idea was to replace it with an dowhile loop but without inverted condition.
until is used in other languages but just as an inversion of a normal while loop, so that might be a problem.

Comma operator `,`

There is no need for a comma operator. Erase it without replacement.

Discussion

The comma operator is sometimes used in C for the for loop. But as we change the for loop anyway, there is one less reason to have these operators.

`union` Type

There really isn't that much of purpose in having a union type. Erase it without replacement.

Discussion

Unions might be handy when working with network protocols. But as NAL shall not target system programmers, that is not really an issue.
Unions can be useful to have either a const or non-const member (as done in NALib). But that might become obsolete with a better type system.

Bitfields

There really isn't that much of purpose in having Bitfields. Erase it without replacement.

Discussion

NAL shall not target system programmers, that is not really an issue.
People are accustomed to use masks on integer values.

Array type `[]`

Ditch the declaration with [] as it induces the usage of pointer arithmetic. Define a built-in array type instead.

Discussion

The [] type evaluates to a pointer to the first element of an array. That has no purpose if we aren't allowing pointer arithmetics anymore.
Arrays must become safe.
When arrays are gone, so are strings. It becomes its own class. Maybe built in to the language. Deal with it.

Pointer arithmetics

Pointer arithmetics are inherently unsafe. We need to get rid of it. The only real thing which needs to be replaced is the array type [] which can be replaced by a built-in type array.

Discussion

This also eliminates one of the primary uses of the arithmetic postfix operators ++ and -- which we will ditch as well.

General `for` loop declaration

The general declaration of a for loop in C like for (init; condition; step) will be removed. Instead, for loops shall only be used for range based loops.

Discussion

Range based loops have become the primary use of for loops.
The three statements init, condition and step were often misused.

`goto` statement

The goto statement has no more use. Remove it completely without replacement.

Discussion

Pros Cons...

`asm` statement

The asm statement shall be removed completely without replacement.

Discussion

NAL shall not target system programmers, so we do not do asm.

`inline` keyword

The inline keyword shall be removed completely without replacement.

Discussion

NAL has no more header files.
Compilers know better than the programmer what shall be inlined.

`register` keyword

The register keyword shall be removed completely without replacement.

Discussion

NAL is not targeted to system programmers.

`volatile` keyword

The volatile keyword shall be removed completely without replacement.

Discussion

NAL is not targeted to system programmers.

`static` keyword

The static keyword shall be removed completely without replacement.

Discussion

We use explicit this parameters to distinguish between static and non-static members and all top level symbols with a dot . are automatically static.

`extern` keyword

The extern keyword shall be removed completely without replacement.

Discussion

The build system automatically detects external symbols.

Multiple variable declaration with comma

Do not define multiple variables with commmas ,.

Discussion

Doesn't cost much time to do it in separate lines.
Isn't a problem anymore when we have no more pointer types.
Looks terrible.

Operators `%=`, `>>=`, `<<=`

Ditch these three operators.

Discussion

%= makes no sense mathematically.
Shift operators are just too seldom.
The operators += -= *= and /= are usefule and simplify programming. Leave them.
The operators &= |= and ^= are useful and simplify programming flags and bools. Leave them

Things to throw away or replace

Arrow operator ->

Discussion

short, long, int, signed, unsigned

char

Discussion

float, double and long double

Discussion

Operators ++ and --

Discussion

Underscore _ as a symbol character

Discussion

do-while

Discussion

Comma operator ,

Discussion

union Type

Discussion

Bitfields

Discussion

Array type []

Discussion

Pointer arithmetics

Discussion

General for loop declaration

Discussion

goto statement

Discussion

asm statement

Discussion

inline keyword

Discussion

register keyword

Discussion

volatile keyword

Discussion

static keyword

Discussion

extern keyword

Discussion

Multiple variable declaration with comma

Discussion

Operators %=, >>=, <<=

Discussion

Arrow operator `->`

`short`, `long`, `int`, `signed`, `unsigned`

`char`

`float`, `double` and `long double`

Operators `++` and `--`

Underscore `_` as a symbol character

`do-while`

Comma operator `,`

`union` Type

Array type `[]`

General `for` loop declaration

`goto` statement

`asm` statement

`inline` keyword

`register` keyword

`volatile` keyword

`static` keyword

`extern` keyword

Operators `%=`, `>>=`, `<<=`