> The following code does not compile:

> typedef int *(foo)(int);

> foo adder_factory(int x)
> {
>   int f(int a)
>   {
>     return a + x;
>   }
>   return &f;
> }

> What's the right way of doing this in C? How can I get closures or
> something similar in C?

> I want to make a factory that produces other functions according to a
> parameter.

> The following code does not compile:

> typedef int *(foo)(int);

> foo adder_factory(int x)
> {
>    int f(int a)
>    {
>      return a + x;
>    }
>    return &f;
> }

> The idea is that adder_factor(42) should be a function that adds 42 to
> whatever it gets passed.

> What's the right way of doing this in C? How can I get closures or
> something similar in C?

> > Hello

> > I want to make a factory that produces other functions according to a
> > parameter.

> > The following code does not compile:

> > typedef int *(foo)(int);

> > foo adder_factory(int x)
> > {
> >    int f(int a)
> >    {
> >      return a + x;
> >    }
> >    return &f;
> > }

> > The idea is that adder_factor(42) should be a function that adds 42 to
> > whatever it gets passed.

> > What's the right way of doing this in C? How can I get closures or
> > something similar in C?

> You can't.

> You can get sort-of simulated closures in complicated and verbose ways,
> but there is no good way to do it.  gcc supports nested functions as an
> extension to C, but that won't give you closures like this.

> If you want to stick close to C, then C++11 supports lambda functions
> and closures.

> If you want to write code that makes strong use of closures in the
> style, then use a programming language that supports it.  The latest C++
> standard will get you the basics, but if you want to write code in a
> more functional programming style, there are much better languages to
> work with (ocaml, python, haskell, etc.)

>>> Hello

>>> I want to make a factory that produces other functions according to a
>>> parameter.

>>> The following code does not compile:

>>> typedef int *(foo)(int);

>>> foo adder_factory(int x)
>>> {
>>>     int f(int a)
>>>     {
>>>       return a + x;
>>>     }
>>>     return &f;
>>> }

>>> The idea is that adder_factor(42) should be a function that adds 42 to
>>> whatever it gets passed.

>>> What's the right way of doing this in C? How can I get closures or
>>> something similar in C?

>> You can't.

>> You can get sort-of simulated closures in complicated and verbose ways,
>> but there is no good way to do it.  gcc supports nested functions as an
>> extension to C, but that won't give you closures like this.

>> If you want to stick close to C, then C++11 supports lambda functions
>> and closures.

>> If you want to write code that makes strong use of closures in the
>> style, then use a programming language that supports it.  The latest C++
>> standard will get you the basics, but if you want to write code in a
>> more functional programming style, there are much better languages to
>> work with (ocaml, python, haskell, etc.)

> scheme

> (and does Python have particularly good support for functional
> programming?)

> I want to make a factory that produces other functions according to a
> parameter.

> The following code does not compile:

> typedef int *(foo)(int);

> foo adder_factory(int x)
> {
>    int f(int a)
>    {
>      return a + x;
>    }
>    return &f;
> }

> The idea is that adder_factor(42) should be a function that adds 42 to
> whatever it gets passed.

> What's the right way of doing this in C? How can I get closures or
> something similar in C?

> > Hello

> > I want to make a factory that produces other functions according to a
> > parameter.

> > The following code does not compile:

> > typedef int *(foo)(int);

> > foo adder_factory(int x)
> > {
> >    int f(int a)
> >    {
> >      return a + x;
> >    }
> >    return &f;
> > }

> > The idea is that adder_factor(42) should be a function that adds 42 to
> > whatever it gets passed.

> > What's the right way of doing this in C? How can I get closures or
> > something similar in C?

> If you have the JIT of lcc-win you write:

> typedef int (*foo)(int);

> foo adder_factory(int value)
> {
>         foo fnPtr;
>         char buf[512];

>         sprintf(buf,"int fn(int a) { return a + %d;}",value);
>         fnPtr = (foo)compile(buf);
>         return fnPtr;

>> typedef int (*foo)(int);

>> foo adder_factory(int value)
>> {
>>         foo fnPtr;
>>         char buf[512];

>>         sprintf(buf,"int fn(int a) { return a + %d;}",value);
>>         fnPtr = (foo)compile(buf);
>>         return fnPtr;

> You could accomplish similiar [though more longwinded] via compiling
> code and using dlopen() to load it into your process space.

> BTW: your code doesn't seem to do any sort of error checking.  What if
> compile() fails?

>> I want to make a factory that produces other functions according to a
>> parameter.

>> The following code does not compile:

>> typedef int *(foo)(int);

>> foo adder_factory(int x)
>> {
>>   int f(int a)
>>   {
>>     return a + x;
>>   }
>>   return &f;
>> }

> C does not have inner functions or closures.

>> The idea is that adder_factor(42) should be a function that adds 42 to
>> whatever it gets passed.

>> What's the right way of doing this in C? How can I get closures or
>> something similar in C?

> typedef struct foo {
>     int (*func)(const struct foo *, int); int param;
> } *foo;

> static int adder(const struct foo *closure, int x) {
>     return closure->param + x;
> }

> foo adder_factory(int x)
> {
>     foo p = malloc(sizeof(*p));
>     p->func = adder;
>     p->param = x;
>     return p;
> }

> #define call_foo(f, x) ((f)->func((f), (x))

>>> What's the right way of doing this in C? How can I get closures or
>>> something similar in C?

>> typedef struct foo {
>>     int (*func)(const struct foo *, int); int param;
>> } *foo;

>> static int adder(const struct foo *closure, int x) {
>>     return closure->param + x;
>> }

>> foo adder_factory(int x)
>> {
>>     foo p = malloc(sizeof(*p));
>>     p->func = adder;
>>     p->param = x;
>>     return p;
>> }

>> #define call_foo(f, x) ((f)->func((f), (x))

> Thanks for the suggestion. Unfortunately I need an actual function, not a
> macro, to be able to pass as a comparator function to qsort.

> Guess I just have to communicate what I need through a global variable?

>>>> What's the right way of doing this in C? How can I get closures or
>>>> something similar in C?

>>> typedef struct foo {
>>>     int (*func)(const struct foo *, int); int param;
>>> } *foo;

>>> static int adder(const struct foo *closure, int x) {
>>>     return closure->param + x;
>>> }

>>> foo adder_factory(int x)
>>> {
>>>     foo p = malloc(sizeof(*p));
>>>     p->func = adder;
>>>     p->param = x;
>>>     return p;
>>> }

>>> #define call_foo(f, x) ((f)->func((f), (x))

>> Thanks for the suggestion. Unfortunately I need an actual function, not
>> a macro, to be able to pass as a comparator function to qsort.

>> Guess I just have to communicate what I need through a global variable?

> That's one alternative. However, you can avoid creating a global, with
> all of the attendant problems. When used correctly, qsort() never calls
> the comparison function with null pointers. You can take advantage of
> that fact by making x a static variable local to the comparison
> function, and if the first argument to that function is a null pointer,
> interpret the second argument as a pointer to a new value for x.

> Yes. It's a well-known problem with all of the original C standard
> library's callback functions. I think C11 has introduced some new
> callbacks, but I haven't had time to learn much about them.

>>> typedef int (*foo)(int);

>>> foo adder_factory(int value)
>>> {
>>>          foo fnPtr;
>>>          char buf[512];

>>>          sprintf(buf,"int fn(int a) { return a + %d;}",value);
>>>          fnPtr = (foo)compile(buf);
>>>          return fnPtr;

>> You could accomplish similiar [though more longwinded] via compiling
>> code and using dlopen() to load it into your process space.

> The intent was for the definition of the adder to be contained inside
> the definition of adder_factory().

>> Both of which are completely OT for this group though.

>> BTW: your code doesn't seem to do any sort of error checking.  What if
>> compile() fails?

>  From the way it's used, it would appear to return a pointer.

> However, I think that compile() looks horribly type-unsafe.

> However, I think that compile() looks horribly type-unsafe.

>> However, I think that compile() looks horribly type-unsafe.

> Type safety in C? That's a novel concept :).

> Is it? Try compiling the following code:

> int main(void)
> {
> double d;
> int *pi = &d;
> return 0;
> }

> > On 22/08/2012 16:05, James Kuyper wrote:

> >> However, I think that compile() looks horribly type-unsafe.

> > Type safety in C? That's a novel concept :).

> Is it? Try compiling the following code:

> int main(void)
> {
>         double d;
>         int *pi = &d;
>         return 0;
> }

> "James Kuyper" <jameskuy...@verizon.net> schrieb im Newsbeitrag
> news:503648B2.5000200@verizon.net...
> ...
>>> Type safety in C? That's a novel concept :).

>> Is it? Try compiling the following code:

>> int main(void)
>> {
>> double d;
>> int *pi = &d;
>> return 0;
>> }

> It compiles! On both Turbo C 2.0 and Borland C++Builder 5.

> There are just 2 warnings:

> Warning J:\C\TURBO2\NONAME.C 4: Suspicious pointer conversion in function
> main
> Warning J:\C\TURBO2\NONAME.C 6: 'pi' is assigned a value which is never used
> in function main

> "James Kuyper" <jameskuy...@verizon.net> schrieb im Newsbeitrag
> news:503648B2.5000200@verizon.net...
> ...
>>> Type safety in C? That's a novel concept :).

>> Is it? Try compiling the following code:

>> int main(void)
>> {
>> double d;
>> int *pi = &d;
>> return 0;
>> }

> It compiles! On both Turbo C 2.0 and Borland C++Builder 5.

> There are just 2 warnings:

> Warning J:\C\TURBO2\NONAME.C 4: Suspicious pointer conversion in function
> main
> Warning J:\C\TURBO2\NONAME.C 6: 'pi' is assigned a value which is never used
> in function main

>>> On 22/08/2012 16:05, James Kuyper wrote:

>>>> However, I think that compile() looks horribly type-unsafe.

>>> Type safety in C? That's a novel concept :).

>> Is it? Try compiling the following code:

>> int main(void)
>> {
>>          double d;
>>          int *pi = &d;
>>          return 0;
>> }

> One additional line (that doesn't involve any casts) is sufficient -

> int main(void)
> {
>      double d;
>      void *pv = &d;
>      int *pi = pv;
>      return 0;
> }

> $ gcc -W -Wall -ansi -pedantic foo.c
> foo.c: In function main :
> foo.c:6:10: warning: unused variable pi

>>> On 22/08/2012 16:05, James Kuyper wrote:

>>>> However, I think that compile() looks horribly type-unsafe.

>>> Type safety in C? That's a novel concept :).

>> Is it? Try compiling the following code:

>> int main(void)
>> {
>>         double d;
>>         int *pi = &d;
>>         return 0;
>> }

> One additional line (that doesn't involve any casts) is sufficient -

> int main(void)
> {
>     double d;
>     void *pv = &d;
>     int *pi = pv;
>     return 0;
> }

>>> However, I think that compile() looks horribly type-unsafe.

>> Type safety in C? That's a novel concept :).

> Is it? Try compiling the following code:

> int main(void)
> {
>    double d;
>    int *pi = &d;
>    return 0;
> }

>>>> However, I think that compile() looks horribly type-unsafe.

>>> Type safety in C? That's a novel concept :).

>> Is it? Try compiling the following code:

>> int main(void)
>> {
>>     double d;
>>     int *pi = &d;
>>     return 0;
>> }

> Yes. It compiles with a warning as expected. Not a great example of type
> safety.

> This code on the other hand compiles with no warnings:

> #include <stdlib.h>

> int main(void)
> {
>      int *ptr = (int*) malloc(sizeof(long));
>      *ptr = 10;
>      short blah = *ptr;
>      free(ptr);
>      exit(EXIT_SUCCESS);
> }

> so please explain how C is a type safe language?

> Try Haskell for a real type safe language.

>>>> However, I think that compile() looks horribly type-unsafe.

>>> Type safety in C? That's a novel concept :).

>> Is it? Try compiling the following code:

>> int main(void)
>> {
>>        double d;
>>        int *pi = &d;
>>        return 0;
>> }

> Yes. It compiles with a warning as expected. Not a great example of type
> safety.

> #include <stdlib.h>

> int main(void)
> {
>    int *ptr = (int*) malloc(sizeof(long));
>    *ptr = 10;
>    short blah = *ptr;
>    free(ptr);
>    exit(EXIT_SUCCESS);
> }

> so please explain how C is a type safe language?