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

On 10/07/2024 19:14, Michael S wrote:

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.
 

Haskell is the first the comes to mind for me, but you could pick any compiled functional programming language.
I am by no means a Haskell expert, and I am not at all familiar with the way the language is compiled.  But it is quite clear that it is an example of a language that has functions as first-class objects, and which is ahead-of-time compiled.  The example below defines an int-to-int function "doubler", and also a function-to-function function "doTwice", and a function quadrupler that is defined as the result of applying the higher-order function doTwice to doubler.  These are all compiled to assembly.
<https://godbolt.org/z/Tb7hGYsdv>
module Example where
doubler :: Int -> Int
doubler x = 2 * x
doTwice :: (Int -> Int) -> (Int -> Int)
doTwice f x = f (f x)
quadrupler = doTwice doubler
shouldBeEighty = quadrupler 20
You can write much the same in C++ using lambdas (which are objects and can be passed around and returned as such) and templates (which are needed because the type of lambdas is hidden).  Unfortunately, this also means that the functions don't get individually generated functions in assembly:
<https://godbolt.org/z/KvPWz3n8z>
auto doubler = [](int x) -> int { return 2 * x; };
auto doTwice = [](auto f) -> auto
{
     return [f](int x) -> int { return f(f(x)); };
};
auto quadrupler = doTwice(doubler);
auto shouldBeEiqhty = quadrupler(20);