Re: do { quit; } else { }

On 12/04/2025 05:33, Janis Papanagnou wrote:

bart <bc@freeuk.com> writes:

>
Rubbish. Everyone finds C declaration syntax a nightmare.

Because of "C"'s somewhat convoluted (IMO "bad") syntax it might
help you to make use of 'typedef's to incrementally construct your
types!

This is a third kind of workround. All of them should be unnecessary. Unless the type really is complicated and needs to be decomposed anyway, whatever the syntax.

C type syntax is just not fit for purpose.

 Reality shows that it *is* (de facto) "fit for purpose". (Probably
not yours. - I'm still wondering why you act in a "C" newsgroup.)

I 100% agree with what C is capable of as a systems language. The level of its type system, its size, its scope, its flexibility (to an extent)
But I also 100% hate its syntax and various other bits and pieces. (OK, about 80% then.)
So I've been avoiding using it for many decades. First because it wasn't practical (acquiring or using it). Then because I wanted to use it but it was just too dreadful. And later I couldn't avoid it because it comes up in every API for every library, or the library comes as C source code.
And APIs use C type syntax. So, yeah, I am entitled to an opinion about it.

 

This is not how a language is
meant to work, and this is not supposed to be the hard part of a
language! Syntax should be the easy bit.

 I agree that language designers can do a much better job. (There's
quite some examples for languages with an IMO "better" syntax.)
 

>
This is that English spec (with the significant bits numbered):
>
   array 10 pointer to func take int return int

 My English might not be good enough, but in my book this is not an
English sentence and for me not (not much)

I gave the full English description further up.

Guessing: An array with 10 elements that are pointers to functions
that take an 'int' parameter and return an 'int' value?

Very good. It's not a guess though is it? If you extract the essential parts out, you get:
    array 10 pointers functions take int return int
The same exercise with mine (both versions) yield:
    array 10 pointers functions take int return int
    array 10 pointer  func      take int return int
There's not much in it.

     1    2   3         4         5         6
>
Here is what CDECL came up with:
>
    int (*A[10])(int);
    6    3 1 2  4 5          (Not sure which bit is the '4')

 (This opening parenthesis syntactically indicates the function, as
also indicated by the numberings above. - Or so I'd think. - No?)

Not necessarily. This is a valid declaration in C:
    int (A);
That opening parentheses is just noise. (I guess you just learned something new about C today?)

>
The numbers below show the correspondence with the English. You can see
it's all over the place. This is how I'd write it in another actual
language syntax:
>
    [10]ref func(int)int A
    1 2 3   4    5   6

 And what should that mean? - You know, since I haven't identified
your "English sentence" as a clearly understandable English sentence

I'm lost here, since I don't know that (your?) language. - For the
"C" case I could at least read the "C" specs (in case I got lost).

A could of years ago I had a bit of fun with it so that my allowed this syntax:
    array [10] pointer to function (int) returning int A
Still have trouble with it? You shouldn't do since this is pretty much what CDECL produces or can understand. I didn't keep this because such syntax is too much.

Assumed that my guess above was correct that's quite equivalent to
the Algol 68 form
    [10] REF PROC (INT) INT a

So you do get it (maybe I should have read this far first). Yes, it directly comes from Algol68.
But left-to-right type specifications must be common now everywhere.

but in Algol 68 you'd probably rather use it without the unnecessary
"pointer"/reference just as in
    [10] PROC (INT) INT a
 which - as you seem to like clearness - is even simpler!

This is not as clear; the intent is to have a reference to a function; not an array of actual functions. For example:
  []ref func(int) int := (F, G, H)
It is initialised to functions F, G, H which are defined elsewhere. Maybe in Algol68 you can have actual function definitions in that list. But not in mine, which was created as a leaner, simpler and more transparent systems language.