On 07.11.2024 18:58, Bonita Montero wrote:

Am 07.11.2024 um 18:47 schrieb fir:

[...]

I think you declare a lot of things you don't understand as crap.

i remember tose inheritance herarhies buit being deeply idiotic and
based on misunderstanding of fundamental things

(You haven't shown in your posts in any way that you'd have
understood even the most "fundamental things" [of OO]. That's
why I'm somewhat irritated by your heated relentless comments.)

Did the code samples you inspected (and that obviously repelled
you) have maybe been written by the "wrong [unknowing] people"?

Since you may not have understood the advantages of OO concepts,
have you taken some effort to try to understand it?

I started OO with Simula 67 at a time where the term "OO" wasn't
widely used, let alone hyped - I think it wasn't even coined at
these days but I'm not sure about it. But the advantages of OO
programming was immediately obvious to me. - I think it needs
some affiliation and openness. Not being spoiled exclusively by
other programming principles might help as well.

Inheritance is not used often, mostly with large class libraries,
but when it is used it makes sense.

Where do you get that impression from that it's not used often?
Or "mostly" with large class libraries? - I certainly made other
observations and had a very different experience.

Whenever I'm operating in an OO language context I'm using its
concepts. Even simple things can be organized advantageously
with OO language concepts, inheritance and polymorphism (based
on inheritance). If you don't make use of its basic concept you
can as well abandon it; for modularity, information hiding, or
abstraction there's other ([supposedly] "simpler") languages.

[...]

[...]

Janis

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

if c would have something that i name as named block
much more interesting options in coding in c would be
imo avaliable..
by named block i understood something like

foo {
//code here
}

whiuch resembles function , as can be placed in 'global'
(module level) space but also could be placed locally in
functions

int foo() {
a { }
b { }
}

then it could be called internally

int foo() {
a { }
b { }

int x = a()*a()*b(); //though imo () probab;ly should be optionall
}

or externally

foo.a()

those blocks probably should have acces to local variables of
parent functions or parant block so it yelds imo to conclusion
that local variables and arguments should be by default static
(those stack variables by default are bad idea imo.. its kinda optimisation needed whan you got 4kb RAM but on bigger machines this optimisation is
bad imo)

if so mant things can be done with this blocks probably, im not exactly
sure what exactly

ona assembly label blocks by defauld probably be done by

name:
//...
ret

so then can be reused though some version to call it in place
of definitions could be also avaliable imo (something like
a{}() in a sense but better looking (this looks to bad)

overally those named block should be also united with function
so they become the same if use on them the functionality of
passing arguments and returning variables

foo {
a {}

int x, y = a(1,2)
}

though i maybe not sure how to add this mechanism
possibly som,ething liek this (until something better could be found)

a
{
in int c;
in int d;
out int x = c+d;
out int y = c-d;
}

or
a( int c, int d)
{
out int x = c+d;
out int y = c-d;
}

as all c d x y are static you may call a() without any or
with any set int x, y = a(1) int x = a(1,2) and compiler
would generate the assigments (how to call it on assembly level us
wuite clear, not fully clear is what syntax in language to use

this concept is yet not fully build yet but what i descrbed her i guess
is okay

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Thiago Adams wrote:

On 06/11/2024 15:46, Thiago Adams wrote:

On 06/11/2024 13:04, fir wrote:

if c would have something that i name as named block
much more interesting options in coding in c would be
imo avaliable..
by named block i understood something like

foo {
//code here
}

whiuch resembles function , as can be placed in 'global'
(module level) space but also could be placed locally in
functions

int foo() {
a { }
b { }
}

then it could be called internally

int foo() {
a { }
b { }

int x = a()*a()*b(); //though imo () probab;ly should be optionall
}

or externally

foo.a()

those blocks probably should have acces to local variables of
parent functions or parant block so it yelds imo to conclusion
that local variables and arguments should be by default static
(those stack variables by default are bad idea imo.. its kinda
optimisation
needed whan you got 4kb RAM but on bigger machines this optimisation
is bad imo)

if so mant things can be done with this blocks probably, im not exactly
sure what exactly

ona assembly label blocks by defauld probably be done by

name:
//...
ret

so then can be reused though some version to call it in place
of definitions could be also avaliable imo (something like
a{}() in a sense but better looking (this looks to bad)

overally those named block should be also united with function
so they become the same if use on them the functionality of
passing arguments and returning variables

foo {
a {}

int x, y = a(1,2)
}

though i maybe not sure how to add this mechanism
possibly som,ething liek this (until something better could be found)

a
{
in int c;
in int d;
out int x = c+d;
out int y = c-d;
}

or
a( int c, int d)
{
out int x = c+d;
out int y = c-d;
}

as all c d x y are static you may call a() without any or
with any set int x, y = a(1) int x = a(1,2) and compiler
would generate the assigments (how to call it on assembly level us
wuite clear, not fully clear is what syntax in language to use

this concept is yet not fully build yet but what i descrbed her i
guess is okay

Names loops (only loops) were proposed to C2Y.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm

Sorry I thought your motivation was exit blocks.
I am not sure what is your motivation now, maybe lambdas? local
functions? long jump?
local jumps?

as to lambdas /closures im not sure as i never learned that concepts
(seem wierd and uglt) but maybe
as if you have blocks you could eventually pass blocks to functions

a {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p();
}

foo(10,a);


its different than pointers as possibly block could have acces to
parent variables..but that would need to be rethinked as it generate
problems (like you eventually cant compile block a above as i is just a
name so this is more liek piece of text not a real code here

eventualy some coud do

a(int i) {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p(i);
}

foo(10,a);

so this is like passing conceptually function to function but not a pointer

but this is all side topic here

more strightforward would be how to do this block arithmetic


a {}
b{ }
c{}

int x = a*b+c;

where a,b,c are blocks of code (though here it would probably mean "run
a" get value and mul by "run b" take value , tun c and add

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Thiago Adams wrote:

On 06/11/2024 15:46, Thiago Adams wrote:

On 06/11/2024 13:04, fir wrote:

if c would have something that i name as named block
much more interesting options in coding in c would be
imo avaliable..
by named block i understood something like

foo {
//code here
}

whiuch resembles function , as can be placed in 'global'
(module level) space but also could be placed locally in
functions

int foo() {
a { }
b { }
}

then it could be called internally

int foo() {
a { }
b { }

int x = a()*a()*b(); //though imo () probab;ly should be optionall
}

or externally

foo.a()

those blocks probably should have acces to local variables of
parent functions or parant block so it yelds imo to conclusion
that local variables and arguments should be by default static
(those stack variables by default are bad idea imo.. its kinda
optimisation
needed whan you got 4kb RAM but on bigger machines this optimisation
is bad imo)

if so mant things can be done with this blocks probably, im not exactly
sure what exactly

ona assembly label blocks by defauld probably be done by

name:
//...
ret

so then can be reused though some version to call it in place
of definitions could be also avaliable imo (something like
a{}() in a sense but better looking (this looks to bad)

overally those named block should be also united with function
so they become the same if use on them the functionality of
passing arguments and returning variables

foo {
a {}

int x, y = a(1,2)
}

though i maybe not sure how to add this mechanism
possibly som,ething liek this (until something better could be found)

a
{
in int c;
in int d;
out int x = c+d;
out int y = c-d;
}

or
a( int c, int d)
{
out int x = c+d;
out int y = c-d;
}

as all c d x y are static you may call a() without any or
with any set int x, y = a(1) int x = a(1,2) and compiler
would generate the assigments (how to call it on assembly level us
wuite clear, not fully clear is what syntax in language to use

this concept is yet not fully build yet but what i descrbed her i
guess is okay

Names loops (only loops) were proposed to C2Y.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm

Sorry I thought your motivation was exit blocks.
I am not sure what is your motivation now, maybe lambdas? local
functions? long jump?
local jumps?

no, it simply gives you more 'power' in code (in means of expression) generally speaking... specifically it may give you various things
but hard to name the possible usacases as it will eventually show

you eventually can think on it itself


it also (as its logical basic concept) gives some thoughts on how
functions are badly done in c - becouse the "stack based" locals
and arguments are bad imo..without it you may do more "tricks"
with code making your code can be shorter and clever sometimes imo

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Thiago Adams wrote:

On 06/11/2024 16:46, fir wrote:

Thiago Adams wrote:

On 06/11/2024 15:46, Thiago Adams wrote:

On 06/11/2024 13:04, fir wrote:

if c would have something that i name as named block
much more interesting options in coding in c would be
imo avaliable..
by named block i understood something like

foo {
//code here
}

whiuch resembles function , as can be placed in 'global'
(module level) space but also could be placed locally in
functions

int foo() {
a { }
b { }
}

then it could be called internally

int foo() {
a { }
b { }

int x = a()*a()*b(); //though imo () probab;ly should be optionall >>>>> }

or externally

foo.a()

those blocks probably should have acces to local variables of
parent functions or parant block so it yelds imo to conclusion
that local variables and arguments should be by default static
(those stack variables by default are bad idea imo.. its kinda
optimisation
needed whan you got 4kb RAM but on bigger machines this optimisation >>>>> is bad imo)

if so mant things can be done with this blocks probably, im not
exactly
sure what exactly

ona assembly label blocks by defauld probably be done by

name:
//...
ret

so then can be reused though some version to call it in place
of definitions could be also avaliable imo (something like
a{}() in a sense but better looking (this looks to bad)

overally those named block should be also united with function
so they become the same if use on them the functionality of
passing arguments and returning variables

foo {
a {}

int x, y = a(1,2)
}

though i maybe not sure how to add this mechanism
possibly som,ething liek this (until something better could be
found)

a
{
in int c;
in int d;
out int x = c+d;
out int y = c-d;
}

or
a( int c, int d)
{
out int x = c+d;
out int y = c-d;
}

as all c d x y are static you may call a() without any or
with any set int x, y = a(1) int x = a(1,2) and compiler
would generate the assigments (how to call it on assembly level us
wuite clear, not fully clear is what syntax in language to use

this concept is yet not fully build yet but what i descrbed her i
guess is okay

Names loops (only loops) were proposed to C2Y.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm

Sorry I thought your motivation was exit blocks.
I am not sure what is your motivation now, maybe lambdas? local
functions? long jump?
local jumps?

as to lambdas /closures im not sure as i never learned that concepts
(seem wierd and uglt) but maybe
as if you have blocks you could eventually pass blocks to functions

a {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p();
}

foo(10,a);


its different than pointers as possibly block could have acces to
parent variables..but that would need to be rethinked as it generate
problems (like you eventually cant compile block a above as i is just
a name so this is more liek piece of text not a real code here

eventualy some coud do

a(int i) {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p(i);
}

foo(10,a);

This is one of the lambda motivations.

maybe , but thsi is just a kinda detail here, as it is not so much
difference than passing pointer though it is a difference

(liek when you pass pointer code takes pointer and here if you pass blck
it acan be simpli compiled in in compile time (and thus it is possible
it can have acces to its all parent fuunction variables).. or may be
called in this "lambda " way as far as i remember that

repeat(10, {printf("zzz")} ); //when reepat is a functin that takes block

but as i said probbaly those blocks could be used for some more things

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 06/11/2024 20:45, fir wrote:

Thiago Adams wrote:

On 06/11/2024 16:46, fir wrote:

Thiago Adams wrote:

On 06/11/2024 15:46, Thiago Adams wrote:

On 06/11/2024 13:04, fir wrote:

if c would have something that i name as named block
much more interesting options in coding in c would be
imo avaliable..
by named block i understood something like

foo {
   //code here
}

whiuch resembles function , as can be placed in 'global'
(module level) space but also could be placed locally in
functions

int foo() {
   a { }
   b { }
}

then it could be called internally

int foo() {
   a { }
   b { }

   int x = a()*a()*b(); //though imo () probab;ly should be optionall >>>>>> }

or externally

foo.a()

those blocks probably should have acces to local variables of
parent functions or parant block so it yelds imo to conclusion
that local variables and arguments should be by default static
(those stack variables by default are bad idea imo.. its kinda
optimisation
needed whan you got 4kb RAM but on bigger machines this optimisation >>>>>> is bad imo)

if so mant things can be done with this blocks probably, im not
exactly
sure what exactly

ona assembly label blocks by defauld probably be done by

name:
   //...
   ret

  so then can be reused though some version to call it in place
  of definitions could be also avaliable imo (something like
  a{}() in a sense but better looking (this looks to bad)

  overally those named block should be also united with function
  so they become the same if use on them the functionality of
  passing arguments and returning variables

  foo {
    a {}

    int x, y = a(1,2)
  }

  though i maybe not sure how to add this mechanism
  possibly som,ething liek this (until something better could be
found)

  a
  {
   in int c;
   in int d;
   out int x = c+d;
   out int y = c-d;
  }

  or
  a( int c, int d)
  {
   out int x = c+d;
   out int y = c-d;
  }

as all c d x y are static you may call a() without any or
with any set int x, y = a(1) int x = a(1,2) and compiler
would generate the assigments (how to call it on assembly level us >>>>>> wuite clear, not fully clear is what syntax in language to use

this concept is yet not fully build yet but what i descrbed her i
guess is okay

Names loops (only loops) were proposed to C2Y.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm

Sorry I thought your motivation was exit blocks.
I am not sure what is your motivation now, maybe lambdas? local
functions? long jump?
local jumps?

as to lambdas /closures im not sure as i never learned that concepts
(seem wierd and uglt) but maybe
as if you have blocks you could eventually pass blocks to functions

a {printf("\n %d", i)}

void foo(int n, block p)
{
   for(int i=0; i<n; i++) p();
}

foo(10,a);


its different than pointers as possibly block could have acces to
parent variables..but that would need to be rethinked as it generate
problems (like you eventually cant compile block a above as i is just
a name so this is more liek piece of text not a real code here

eventualy some coud do

a(int i) {printf("\n %d", i)}

void foo(int n, block p)
{
   for(int i=0; i<n; i++) p(i);
}

foo(10,a);

This is one of the lambda motivations.

maybe , but thsi is just a kinda detail here, as it is not so much
difference than passing pointer though it is a difference

(liek when you pass pointer code takes pointer and here if you pass blck
it acan be simpli compiled in in compile time (and thus it is possible
it can have acces to its all parent fuunction variables).. or may be
called in this "lambda " way as far as i remember that

repeat(10, {printf("zzz")} ); //when reepat is a functin that takes block

but as i said probbaly those blocks could be used for some more things

Some of this stuff, like local functions, is in gnu C.

Most other complex stuff, passing lamda functions, you will find in C++.

But unless it is already in gnu, or has been added to C23 (which may
take a decade to become common), C is not going to acquire any random
proposals that you make in threads like this.

At best you might modify one implementation to try out an idea.

I'm not really into either, but I have tried anonymous functions
(without closures) in my scripting language. Your example looks like
this (using near-identical syntax):

proc myrepeat(n, body) =
to n do
body()
end
end

proc main =
myrepeat(10, {printf("zzz")})
end

The lack of closures means the anonymous function inside {...} can't
access any stack-based names outside which are part of the enclosing
function.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

fir wrote:

Bart wrote:

On 06/11/2024 20:45, fir wrote:

Thiago Adams wrote:

On 06/11/2024 16:46, fir wrote:

Thiago Adams wrote:

On 06/11/2024 15:46, Thiago Adams wrote:

On 06/11/2024 13:04, fir wrote:

if c would have something that i name as named block
much more interesting options in coding in c would be
imo avaliable..
by named block i understood something like

foo {
//code here
}

whiuch resembles function , as can be placed in 'global'
(module level) space but also could be placed locally in
functions

int foo() {
a { }
b { }
}

then it could be called internally

int foo() {
a { }
b { }

int x = a()*a()*b(); //though imo () probab;ly should be
optionall
}

or externally

foo.a()

those blocks probably should have acces to local variables of
parent functions or parant block so it yelds imo to conclusion >>>>>>>> that local variables and arguments should be by default static >>>>>>>> (those stack variables by default are bad idea imo.. its kinda >>>>>>>> optimisation
needed whan you got 4kb RAM but on bigger machines this
optimisation
is bad imo)

if so mant things can be done with this blocks probably, im not >>>>>>>> exactly
sure what exactly

ona assembly label blocks by defauld probably be done by

name:
//...
ret

so then can be reused though some version to call it in place >>>>>>>> of definitions could be also avaliable imo (something like
a{}() in a sense but better looking (this looks to bad)

overally those named block should be also united with function >>>>>>>> so they become the same if use on them the functionality of
passing arguments and returning variables

foo {
a {}

int x, y = a(1,2)
}

though i maybe not sure how to add this mechanism
possibly som,ething liek this (until something better could be >>>>>>>> found)

a
{
in int c;
in int d;
out int x = c+d;
out int y = c-d;
}

or
a( int c, int d)
{
out int x = c+d;
out int y = c-d;
}

as all c d x y are static you may call a() without any or
with any set int x, y = a(1) int x = a(1,2) and compiler
would generate the assigments (how to call it on assembly level us >>>>>>>> wuite clear, not fully clear is what syntax in language to use >>>>>>>>
this concept is yet not fully build yet but what i descrbed her i >>>>>>>> guess is okay

Names loops (only loops) were proposed to C2Y.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm

Sorry I thought your motivation was exit blocks.
I am not sure what is your motivation now, maybe lambdas? local
functions? long jump?
local jumps?

as to lambdas /closures im not sure as i never learned that concepts >>>>> (seem wierd and uglt) but maybe
as if you have blocks you could eventually pass blocks to functions

a {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p();
}

foo(10,a);


its different than pointers as possibly block could have acces to
parent variables..but that would need to be rethinked as it generate >>>>> problems (like you eventually cant compile block a above as i is just >>>>> a name so this is more liek piece of text not a real code here

eventualy some coud do

a(int i) {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p(i);
}

foo(10,a);

This is one of the lambda motivations.

maybe , but thsi is just a kinda detail here, as it is not so much
difference than passing pointer though it is a difference

(liek when you pass pointer code takes pointer and here if you pass blck >>> it acan be simpli compiled in in compile time (and thus it is possible
it can have acces to its all parent fuunction variables).. or may be
called in this "lambda " way as far as i remember that

repeat(10, {printf("zzz")} ); //when reepat is a functin that takes
block

but as i said probbaly those blocks could be used for some more things

Some of this stuff, like local functions, is in gnu C.

Most other complex stuff, passing lamda functions, you will find in C++.

But unless it is already in gnu, or has been added to C23 (which may
take a decade to become common), C is not going to acquire any random
proposals that you make in threads like this.

At best you might modify one implementation to try out an idea.

I'm not really into either, but I have tried anonymous functions
(without closures) in my scripting language. Your example looks like
this (using near-identical syntax):

proc myrepeat(n, body) =
to n do
body()
end
end

proc main =
myrepeat(10, {printf("zzz")})
end

The lack of closures means the anonymous function inside {...} can't
access any stack-based names outside which are part of the enclosing
function.

normally this {printf("zzz")} cant acces not opnly stack based but any
local variables imo... (by 'normally' i mean without breaking some
present default rules.. i mean it in fact aces any like

foo({printf("zzz%d%d%d",a,b,c)}); but it just mean it more work like c++ template which "lives" only before compilation - as here a,b,c are just
texts which can be resolved at compile time to different things

- and this is not neccesart the thing im thinking about here (generally
i prefer the constructs that live after compilation, but those
eventually also could be considered

thoce stack based variables and arguments are bad for other reasons.. generally the amount of "tricks" compiler and programmer van do when arguments and locals are by default static is much greater and
quite usable and imo programs coild eventually be probably faster

(i already wrote on this back then

for example i thing if you giot such wunstion

DrawText(10,10,"some");

wchich draw text beginnmh in 10 row 10th column of text console
then you eventually can call yhis function also like

DrawText(10,10,"some");
DrawText(" more");

which just skips the passing row and column and reuses its states
whch say last call set to end of previous writting

you also could have acces to them like DrawText.row

if they are stack based it seem it couldnt be probably done

its also more efective becouse you dont need that memory bandwidth to
set thiose variables if you dont need to set them or bass them back
when you need or dont need to acces them

on definition side it needs hovever some syntax to allow that
its something like

DrawText(static int row , static int column , static char* text)
{
DrawText( char* text)
{

//code here
}
}

its liek two entry points when second just omits two assigments,
some things like that can be also done in earlier or later return at the
end when separate call to the same function can calculate more return wariabl;es or less and as return values are static you may use not all

generally i think about something like

mul(int x, int y)
{
static int low;
//compute x*y and if it fits in int low, return

static int high;
//if it also has high part compute high and return
}


in classic way you would need to fill and return both i guess

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bart wrote:

On 06/11/2024 20:45, fir wrote:

Thiago Adams wrote:

On 06/11/2024 16:46, fir wrote:

Thiago Adams wrote:

On 06/11/2024 15:46, Thiago Adams wrote:

On 06/11/2024 13:04, fir wrote:

if c would have something that i name as named block
much more interesting options in coding in c would be
imo avaliable..
by named block i understood something like

foo {
//code here
}

whiuch resembles function , as can be placed in 'global'
(module level) space but also could be placed locally in
functions

int foo() {
a { }
b { }
}

then it could be called internally

int foo() {
a { }
b { }

int x = a()*a()*b(); //though imo () probab;ly should be
optionall
}

or externally

foo.a()

those blocks probably should have acces to local variables of
parent functions or parant block so it yelds imo to conclusion
that local variables and arguments should be by default static
(those stack variables by default are bad idea imo.. its kinda
optimisation
needed whan you got 4kb RAM but on bigger machines this optimisation >>>>>>> is bad imo)

if so mant things can be done with this blocks probably, im not
exactly
sure what exactly

ona assembly label blocks by defauld probably be done by

name:
//...
ret

so then can be reused though some version to call it in place
of definitions could be also avaliable imo (something like
a{}() in a sense but better looking (this looks to bad)

overally those named block should be also united with function >>>>>>> so they become the same if use on them the functionality of
passing arguments and returning variables

foo {
a {}

int x, y = a(1,2)
}

though i maybe not sure how to add this mechanism
possibly som,ething liek this (until something better could be >>>>>>> found)

a
{
in int c;
in int d;
out int x = c+d;
out int y = c-d;
}

or
a( int c, int d)
{
out int x = c+d;
out int y = c-d;
}

as all c d x y are static you may call a() without any or
with any set int x, y = a(1) int x = a(1,2) and compiler
would generate the assigments (how to call it on assembly level us >>>>>>> wuite clear, not fully clear is what syntax in language to use

this concept is yet not fully build yet but what i descrbed her i >>>>>>> guess is okay

Names loops (only loops) were proposed to C2Y.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm

Sorry I thought your motivation was exit blocks.
I am not sure what is your motivation now, maybe lambdas? local
functions? long jump?
local jumps?

as to lambdas /closures im not sure as i never learned that concepts
(seem wierd and uglt) but maybe
as if you have blocks you could eventually pass blocks to functions

a {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p();
}

foo(10,a);


its different than pointers as possibly block could have acces to
parent variables..but that would need to be rethinked as it generate
problems (like you eventually cant compile block a above as i is just
a name so this is more liek piece of text not a real code here

eventualy some coud do

a(int i) {printf("\n %d", i)}

void foo(int n, block p)
{
for(int i=0; i<n; i++) p(i);
}

foo(10,a);

This is one of the lambda motivations.

maybe , but thsi is just a kinda detail here, as it is not so much
difference than passing pointer though it is a difference

(liek when you pass pointer code takes pointer and here if you pass blck
it acan be simpli compiled in in compile time (and thus it is possible
it can have acces to its all parent fuunction variables).. or may be
called in this "lambda " way as far as i remember that

repeat(10, {printf("zzz")} ); //when reepat is a functin that takes block

but as i said probbaly those blocks could be used for some more things

Some of this stuff, like local functions, is in gnu C.

Most other complex stuff, passing lamda functions, you will find in C++.

But unless it is already in gnu, or has been added to C23 (which may
take a decade to become common), C is not going to acquire any random proposals that you make in threads like this.

At best you might modify one implementation to try out an idea.

I'm not really into either, but I have tried anonymous functions
(without closures) in my scripting language. Your example looks like
this (using near-identical syntax):

proc myrepeat(n, body) =
to n do
body()
end
end

proc main =
myrepeat(10, {printf("zzz")})
end

The lack of closures means the anonymous function inside {...} can't
access any stack-based names outside which are part of the enclosing function.

normally this {printf("zzz")} cant acces not opnly stack based but any
local variables imo... (by 'normally' i mean without breaking some
present default rules.. i mean it in fact aces any like

foo({printf("zzz%d%d%d",a,b,c)}); but it just mean it more work like c++ template which "lives" only before compilation - as here a,b,c are just
texts which can be resolved at compile time to different things

- and this is not neccesart the thing im thinking about here (generally
i prefer the constructs that live after compilation, but those
eventually also could be considered

thoce stack based variables and arguments are bad for other reasons..
generally the amount of "tricks" compiler and programmer van do when
arguments and locals are by default static is much greater and
quite usable and imo programs coild eventually be probably faster

(i already wrote on this back then

for example i thing if you giot such wunstion

DrawText(10,10,"some");

wchich draw text beginnmh in 10 row 10th column of text console
then you eventually can call yhis function also like

DrawText(10,10,"some");
DrawText(" more");

which just skips the passing row and column and reuses its states
whch say last call set to end of previous writting

you also could have acces to them like DrawText.row

if they are stack based it seem it couldnt be probably done

its also more efective becouse you dont need that memory bandwidth to
set thiose variables if you dont need to set them or bass them back
when you need or dont need to acces them

on definition side it needs hovever some syntax to allow that
its something like

DrawText(static int row , static int column , static char* text)
{
DrawText( char* text)
{

//code here
}
}

its liek two entry points when second just omits two assigments,
some things like that can be also done in earlier or later return at the
end when separate call to the same function can calculate more return wariabl;es or less and as return values are static you may use not all

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 06.11.2024 um 20:46 schrieb fir:

a {}
b{ }
c{}

int x = a*b+c;

where a,b,c are blocks of code (though here it would probably mean
"run a" get value and mul by "run b" take value , tun c and add

Use C++ and lambdas.

c++ has so many structural errors it makes it sh*t
(overaly all c++ is structural errors .. prbably one and only
thing interesting in c++ is operator overloading but it also is badly
done ofc)

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

fir wrote:

Bonita Montero wrote:

Am 06.11.2024 um 20:46 schrieb fir:

a {}
b{ }
c{}

int x = a*b+c;

where a,b,c are blocks of code (though here it would probably mean
"run a" get value and mul by "run b" take value , tun c and add

Use C++ and lambdas.

c++ has so many structural errors it makes it sh*t
(overaly all c++ is structural errors .. prbably one and only
thing interesting in c++ is operator overloading but it also is badly
done ofc)

besides you could do more than this lambda does , i guess
(i dont quite remember what this lambda is)

like some can define operators on this blocks for more than arithmetic
on return values

like this "inject " a<-b

a is called and it cals b from inside

b {beep();}

a(block f) {
for(int i=0; i<10; i++) f()
}

or something more complex in this spirit (i dont know what hoveve)

maybe also thiose blocks simply could be used to allow code be shorter,
i dont know

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 07.11.2024 um 16:55 schrieb fir:

c++ has so many structural errors it makes it sh*t
(overaly all c++ is structural errors .. prbably one and only
thing interesting in c++ is operator overloading but it also
is badly done ofc)

What do you consider as a "structural error" with C++ ?

many things there are simply idiotic

liek for exampe concept of suntypes and sueprtypes

when for example you got some entity that

some {
sing(); swim(); fly(); }

the subtypes are things that
1{sing(); }
2 { swim();
3 { fly();}
4 {sing(); swim(); }
5 { swim(), fly()} ;
6 { sing(); fly();}

and supertype is {
sing(); swim(); fly(); + do more}

not that idiotism of c++

also oop is hevily idiotoc ehen in normal languege you
can use and connect entities (just by putting them in visibility)
without all that idiotic pointers

thsi i call syructural errors becouse you can do things in normal
structurally correct way in c++ this is total idiotism in that place

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 07.11.2024 um 18:01 schrieb fir:

the subtypes are things that 1{sing(); } 2 { swim(); 3 { fly();} 4
{sing(); swim(); } 5 { swim(), fly()} ; 6 { sing(); fly();}

With that you could use three interfaces (classes with only pure
virtual functions) and derive them as needed. That's still OOP. OOP
is useful and a standard.

i dont remember i learned a c++ a bit in about year 2001 or so (i dont
even remember) and then droipped the learning noticing how crap it is

i remember tose inheritance herarhies buit being deeply idiotic and
based on misunderstanding of fundamental things


same with those builtin c++ spaghetti with new objest and
pointers... this c++ OOP is indeed just a monster sphagetti

all those pointers ale nonsense.. the entities with functions are okay
but visibility by pointers is deeply idiotic if yu get some entity you
need to use simply add them like

Sccreen screen1, screen2;
Ship ship[100];

then just call its methods and more... no idiotic sphagetti

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

fir wrote:

Bonita Montero wrote:

Am 07.11.2024 um 18:01 schrieb fir:

the subtypes are things that 1{sing(); } 2 { swim(); 3 { fly();} 4
{sing(); swim(); } 5 { swim(), fly()} ; 6 { sing(); fly();}

With that you could use three interfaces (classes with only pure
virtual functions) and derive them as needed. That's still OOP. OOP
is useful and a standard.

i dont remember i learned a c++ a bit in about year 2001 or so (i dont
even remember) and then droipped the learning noticing how crap it is

i remember tose inheritance herarhies buit being deeply idiotic and
based on misunderstanding of fundamental things

same with those builtin c++ spaghetti with new objest and
pointers... this c++ OOP is indeed just a monster sphagetti

i remember a movei die herd 2 adair and then a 'simon' says imo
with memoprable voice (fort knox) "its for tourists!", close woice i
would say: "c++? Its for idiots!" ;c

all those pointers ale nonsense.. the entities with functions are okay
but visibility by pointers is deeply idiotic if yu get some entity you
need to use simply add them like

Sccreen screen1, screen2;
Ship ship[100];

then just call its methods and more... no idiotic sphagetti

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 07.11.2024 um 18:47 schrieb fir:

i dont remember i learned a c++ a bit in about year 2001 or so (i dont
even remember) and then droipped the learning noticing how crap it is

I think you declare a lot of things you don't understand as crap.

i remember tose inheritance herarhies buit being deeply idiotic and
based on misunderstanding of fundamental things

Inheritance is not used often, mostly with large class libraries,
but when it is used it makes sense.

same with those builtin c++ spaghetti with new objest and
pointers... this c++ OOP is indeed just a monster sphagetti

The OOP-rules are almost the same as in Java.

java is also terreible sphagetti crap if course (but at least hava was
not offending c as c++ adding sphagetti crap to c)

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 07.11.2024 um 19:09 schrieb fir:

java is also terreible sphagetti crap if course (but at least hava was
not offending c as c++ adding sphagetti crap to c)

Seems you're overburdened with everything.
Java is the number one language for business applications for good
reason. The language is moderately powerful (compared to C#), easy
to learn and there are high-quality class libraries for every imagi-
nable use case for business applications.

so what ? you think milions of people dont do stupid things?
they do all the time.. but okay i dont want to talko about this, you
asked a question

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 07.11.2024 um 21:37 schrieb fir:

Bonita Montero wrote:

Am 07.11.2024 um 19:09 schrieb fir:

java is also terreible sphagetti crap if course (but at least hava was >>>> not offending c as c++ adding sphagetti crap to c)

Seems you're overburdened with everything.
Java is the number one language for business applications for good
reason. The language is moderately powerful (compared to C#), easy
to learn and there are high-quality class libraries for every imagi-
nable use case for business applications.

so what ? you think milions of people dont do stupid things?

Should they write business code in C and have tousands of buffer
overflows ?

possibly if you woild write it - if you think writing on c is buffer
overflow for you

they do all the time.. but okay i dont want to talko about this, you
asked a question

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 08.11.2024 um 16:58 schrieb fir:

possibly if you woild write it - if you think writing on c is buffer
overflow for you

C is not suitable for business applications. With that you don't need
that much control over technical details and half the performacne is sufficient. In C you'd write ten times the code and the code is much
more error-prone.

well first of all i was not saying c is suitable for business aplication
i dont know
it is just pssible that companies can only hire idiots and idiots may
noy be good in c etc

what i was sayin that c++ has terroble structural errors

(yet to say big prgrams like windows linux wa swritten in c so that is
kinda proof etc, but i dont want to talk this kind of idiotic
konversatiion when yoy belive something and will repeat it to me
on and on as usual...

in fact youre not c coder on c group and you share you opinions not
javing experience in c coding against people who can code in c and know
how it is going)

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Bonita Montero wrote:

Am 08.11.2024 um 18:55 schrieb fir:

what i was sayin that c++ has terroble structural errors

I asked you what are the errors and you've shown that you
didn't understand the language.

i must throw you out a group of people worth talking..youere like dick
hodgin, maniacal jesus belivver who fortunatelly as i guiuess finaly
gone to hell

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)