Mastering the C Clockwise Spiral Rule for Parsing Declarations

Being taught this rule in undergrad really hampered my appreciation of C. As I've said in a previous comment, the real key that unlocked understanding C declarations for me is the mantra "declaration follows use." You declare a variable in C in exactly the same way you would use it: if you know how to use a variable, then you know how to read and write a declaration for it. Once I understood this elegant idea, it became hard to enjoy using statically typed languages that eschew it.

It is explained in more detail at this link:

https://eigenstate.org/notes/c-decl

My ideal syntax for function pointers is:

fn signal(signum: int, fp: fn(int -> void)) -> fn(int -> void)

It keeps the parameter and return types inside, makes it obvious that it's a function using the fn keyword (or func or whatever), short and readable.

When you add more parameters you get `fn(int, char -> int)`. That's the only sane way to handle it and it also supports multiple return values if you want them.

Bonus: all type modifiers should be prefix like `?*MyStruct` and control flow should be postfix `task.await.match { ... }`. Every language should either have a pipe operator or let you call any function with method syntax. `x |> f |> g` is better than `g(f(x))`.

D simply reads right to left:

int[]* p; // pointer to array of int

int function(char*) fp; // pointer to function with char* parameter returning an int

> "str is an array 10 of pointers to char"

Wow, imagine if it was possible to actually use a language like that do declare the type of the variable like that? Something like

str: array [0..9] of ^Char;

or even

var str [10]*uint8

Just imagine...