Re: technology discussion → does the world need a "new" C ?

On 7/11/2024 4:29 PM, Tim Rentsch wrote:

BGB <cr88192@gmail.com> writes:
 

On 7/11/2024 9:02 AM, Tim Rentsch wrote:
>

Michael S <already5chosen@yahoo.com> writes:
>

On Wed, 10 Jul 2024 08:48:05 -0700
Tim Rentsch <tr.17687@z991.linuxsc.com> wrote:
>

bart <bc@freeuk.com> writes:
>

I earlier asked this:
>
"So if arrays aren't passed by value in C, and they aren't passed
by reference, then how the hell ARE they passed?!"

>
They aren't.  C allows lots of things to be passed as an argument
to a function:  several varieties of numeric values, structs,
unions, and pointers, including both pointers to object types and
pointers to function types.  C does not have a way for a function
to take an argument that is either an array or a function.  There
is a way to take pointers to those things, but not the things
themselves.  Arrays and functions are second-class values in C.

>
I'd like to see an example of the language that permits ahead-of-time
compilation and has functions as first-class values.

>
C is almost that language.  Pointers to functions are first class
in C.  If for every C function definition a pattern like this:
>
      static int
      foo_implementation( int x ){
          return  x > 0 ? -x : x;
      }
>
      int (*foo)( int ) = foo_implementation;
>
is used, and there are no other references to the _implementation
names, then "functions" like foo() are essentially first-class
functions.  The "function" foo can be assigned into.  It can be
called just like an actual C function.  The type of a "function"
is not like an actual function type, and so for example how the
address-of operator works is different for "functions" than it is
for actual C functions.  Also pre-declarations for "functions"
obviously need to be different than they would be for actual C
functions.  If the necessary adjustments are made, we would have
a language with first-class "functions".
>
Incidentally, whether a language has closures is orthogonal to
the question of whether functions are first class.  Closures
might or might not be interoperable with functions (they are
in some languages, and not in others).  But that needn't have
any bearing on whether functions (or closures) are first class.
>
Note: strictly speaking a closure is a run-time value, not a
compile-time definition.  I trust my readers are able to make
the needed linguistic accommodations.

>
FWIW, there was a proposal to add C++ style lambdas to C23, but
apparently didn't get in.  [...]

 IMO the more C ignores or moves away from C++ the better.

Possibly, though some amount of the features they did add to C23 were "C++ flavored".
Though, the proposal did differ on one major point:
   The C++ version was some sort of opaque type;
   The C version was a function pointer.
Though, any option other than function pointers is likely non-workable though...
My own previous syntax was more like:
   __var(args):type { body }   //by-value
   __var!(args):type { body }  //by-ref
Rather than:
   [capture](args)->type { body }
But, wasn't that hard to add support for the latter notation in the parser (and allows specify capture type per variable).
But, yeah...
Lambdas are still not seeing a whole lot of use either way...