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

On 11/07/2024 10:15, Michael S wrote:

On Thu, 11 Jul 2024 08:41:14 -0000 (UTC)
Kaz Kylheku <643-408-1753@kylheku.com> wrote:
 

On 2024-07-11, Michael S <already5chosen@yahoo.com> wrote:

I fail to see a material difference between first class function
values in Haskell and C++ and first class function pointer values
in C:
>
int doubler(int x) {
   return x*2;
}
int doTwice(int (*foo)(int), int x) {
   return foo(foo(x));
}
int quadrupler(int x) {
   return doTwice(doubler, x);
}
>
I am willing to believe that the difference exists, but your
example is too basic to demonstrate it.

>
First class functions could do something like this:
>
   // multiplier takes a coefficient and returns a pointer to
   // function
>
   int (*multiplier(int coefficient))(int) {
      // fantasy lambda syntax. Return type int is written after
      // parameter list.
      return lambda(int x) int {
         return coefficient * x;
      }
   }
>
   int (*doubler)(int) = multiplier(2);
>
   int x = doubler(42); // x becomes 84
>
Even though the lambda is returned out of multiplier, whose execution
terminates, when the returned function is invoked, it can refer to the
coefficient, which is captured in a lexical closure.
>
With a C-like typedef, we can declutter the definition of mutiplier:
>
   typedef int (*int_int_fn)(int);
>
   int_int_fn multiplier(int coefficient) {
      return lambda(int x) int {
         return coefficient * x;
      }
   }
>

 Thank you.
Your example confirms my suspicion that the difference between first
and second class of functions doesn't become material until language
supports closures.
 

There are multiple classes of functions. Closures are part of it but there are several versions of closures too:
                       Reference   Closure
Normal functions        -           -
Function pointers       Y           -
Anonymous functions     Y           -
Anonymous functions     Y           1
Anonymous functions     Y           2
Anonymous functions     Y           ...
C supports the first two, as does my static language. My dynamic language supports the first 3 (and can emulate the next couple of levels)
With closures, they can have different capabilities (as you discover when you manage to implement something that runs the simpler Wikipedia examples, then move on to the next which fails).
For example, in managing to still work after the containing function in the above example returns. Or in being able to update that 'coefficient' variable in a still-active enclosing function.
Whatever you do, there will exist a more elaborate, subtler example that will fail. But it will also be one that few can understand or predict anyway.