it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it is 'blocked' from usage
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it is
'blocked' from usage
#include <stdio.h>this (T) is rather silly here - i mean its ok if you cast something but
typedef struct {int x,y;} T;
int main(void) {
-a-a-a T s;
-a-a-a s = (T){10,20};
}
bartc pisze:
On 01/11/2026 13:32, fir wrote:this (T) is rather silly here - i mean its ok if you cast something but
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it is
'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
if no its like
int a = (int) 20;
fir pisze:
bartc pisze:
On 01/11/2026 13:32, fir wrote:this (T) is rather silly here - i mean its ok if you cast something
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it
is 'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
but if no its like
int a = (int) 20;
logically
x = {2,3};
as an assigment is kinda ok
if some told some need to have a different syntax for initialisation
then in fact
x = {2,3};
more fit to assigment than initialisation and some could tke something
other to denote nitialisation
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it is
'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a T s;
-a-a-a s = (T){10,20};
}
On 01/11/2026 14:41, bartc wrote:
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it is
'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
As often seems to be the case, things Fir wants are already available in C++.
In C, you need to give a type to "{ 10, 20 }" - as you did here, making
it into a compound literal.-a The expression "{ 10, 20 }" on its own
cannot be used for assignment to "s" because the type of an expression
must be determined from the expression alone - not from what you are assigning it to.
In C++, "s = { 10, 20 };" is valid because "{ 10, 20 }" is treated asIn the language or compiler? Because machinery can be added to C too.
type std::initializer_list<int> (the "int" part is automatically inferred).-a Making this work involves quite a bit of additional C++ machinery that does not exist in C.
On 02/11/2026 16:36, David Brown wrote:
On 01/11/2026 14:41, bartc wrote:
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it
is 'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
As often seems to be the case, things Fir wants are already available
in C++.
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal.-a The expression "{ 10, 20 }" on its
own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
I think this has been discussed recently but I can't remember the
arguments.
But people can write:
-a-a x = 0;
and the exact type of '0' can be determined from the type of 'x', so I
don't see much difference.
Plus it doesn't see to be a problem here:
-a T s = {10, 20};
What determines the type of {10, 20} in this case?
In the language or compiler? Because machinery can be added to C too.
In C++, "s = { 10, 20 };" is valid because "{ 10, 20 }" is treated as
type std::initializer_list<int> (the "int" part is automatically
inferred).-a Making this work involves quite a bit of additional C++
machinery that does not exist in C.
bartc pisze:
On 02/11/2026 16:36, David Brown wrote:you once asked if i want some of what i talk someone should implement
On 01/11/2026 14:41, bartc wrote:
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied) >>>>>
with this {0,0,1} at least c has a basic of ths vector/tupple support >>>>> and this 'native' support is quite standable..so its very weird it
is 'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
As often seems to be the case, things Fir wants are already available
in C++.
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal.-a The expression "{ 10, 20 }" on
its own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
I think this has been discussed recently but I can't remember the
arguments.
But people can write:
-a-a-a x = 0;
and the exact type of '0' can be determined from the type of 'x', so I
don't see much difference.
Plus it doesn't see to be a problem here:
-a-a T s = {10, 20};
What determines the type of {10, 20} in this case?
In the language or compiler? Because machinery can be added to C too.
In C++, "s = { 10, 20 };" is valid because "{ 10, 20 }" is treated as
type std::initializer_list<int> (the "int" part is automatically
inferred).-a Making this work involves quite a bit of additional C++
machinery that does not exist in C.
etc...
in fact i dont care those are some observations, and i may wait
implement it myself but also someone (espe like c comitee) could
implement it imo (some of it those closer to c)
but it geerally seems this comitee is don bad work
ythse some basic changes and obvious exchanges like hera baove
or this that 'bhdbdh' would work they should do
i think what not breaks compatibility and what is really sane and not
rises special objections they should do
On 02/11/2026 16:36, David Brown wrote:
On 01/11/2026 14:41, bartc wrote:
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied)
with this {0,0,1} at least c has a basic of ths vector/tupple support
and this 'native' support is quite standable..so its very weird it
is 'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
As often seems to be the case, things Fir wants are already available
in C++.
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal.-a The expression "{ 10, 20 }" on its
own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
I think this has been discussed recently but I can't remember the
arguments.
But people can write:
-a-a x = 0;
and the exact type of '0' can be determined from the type of 'x', so I
don't see much difference.
Plus it doesn't see to be a problem here:
-a T s = {10, 20};
What determines the type of {10, 20} in this case?
In the language or compiler? Because machinery can be added to C too.
In C++, "s = { 10, 20 };" is valid because "{ 10, 20 }" is treated as
type std::initializer_list<int> (the "int" part is automatically
inferred).-a Making this work involves quite a bit of additional C++
machinery that does not exist in C.
[...] - just use C++.
[...]
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal. The expression "{ 10, 20 }" on its
own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
On 02/11/2026 19:47, bartc wrote:
On 02/11/2026 16:36, David Brown wrote:
On 01/11/2026 14:41, bartc wrote:
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be
stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied) >>>>>
with this {0,0,1} at least c has a basic of ths vector/tupple support >>>>> and this 'native' support is quite standable..so its very weird it
is 'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
As often seems to be the case, things Fir wants are already available
in C++.
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal.-a The expression "{ 10, 20 }" on
its own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
I think this has been discussed recently but I can't remember the
arguments.
But people can write:
-a-a-a x = 0;
and the exact type of '0' can be determined from the type of 'x', so I
don't see much difference.
No, 0 is of type "int".-a As an integer constant expression with value 0,
it can be /converted/ to any pointer type, giving a null pointer
constant.-a It can also be converted to a float, or other arithmetic
type.-a But as it stands, "0" has a fixed type - "int".
Plus it doesn't see to be a problem here:
-a-a T s = {10, 20};
What determines the type of {10, 20} in this case?
That is initialisation, which is a different matter.-a Critically, it is
a declaration and not an expression - it does not produce a value that
can itself be used.
(I'd be happy if assignment were a particular kind of statement, rather
than an expression.-a I'd be happy if "s = { 10, 20 };" worked in C.-a It doesn't work in C, however - this is one of many reasons why I usually
work in C++ rather than C.)
In the language or compiler? Because machinery can be added to C too.
In C++, "s = { 10, 20 };" is valid because "{ 10, 20 }" is treated as
type std::initializer_list<int> (the "int" part is automatically
inferred).-a Making this work involves quite a bit of additional C++
machinery that does not exist in C.
std::initializer_list is a template.-a Making templates work in C would require so many changes that it would be pointless - just use C++.
Maybe the assignment could be made to work in other ways that could be
more feasible to add to C.-a It's not something I have thought through in detail.
On 02/11/2026 20:29, David Brown wrote:
On 02/11/2026 19:47, bartc wrote:
On 02/11/2026 16:36, David Brown wrote:
On 01/11/2026 14:41, bartc wrote:
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be >>>>>> stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied) >>>>>>
with this {0,0,1} at least c has a basic of ths vector/tupple support >>>>>> and this 'native' support is quite standable..so its very weird it >>>>>> is 'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
As often seems to be the case, things Fir wants are already
available in C++.
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal.-a The expression "{ 10, 20 }" on
its own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
I think this has been discussed recently but I can't remember the
arguments.
But people can write:
-a-a-a x = 0;
and the exact type of '0' can be determined from the type of 'x', so
I don't see much difference.
No, 0 is of type "int".-a As an integer constant expression with value
0, it can be /converted/ to any pointer type, giving a null pointer
constant.-a It can also be converted to a float, or other arithmetic
type.-a But as it stands, "0" has a fixed type - "int".
Same thing. Here there is a tuple of two ints. (The syntax might be problematical in C outside of initialisation or following a cast.)
Such tuples can be used without having to expose them in the language.
They already occur here: (T){10, 20}.
Plus it doesn't see to be a problem here:
-a-a T s = {10, 20};
What determines the type of {10, 20} in this case?
That is initialisation, which is a different matter.-a Critically, it
is a declaration and not an expression - it does not produce a value
that can itself be used.
But it manages to figure out the types. (Even if it is not fussy about nested {} grouping.)
(I'd be happy if assignment were a particular kind of statement,
rather than an expression.-a I'd be happy if "s = { 10, 20 };" worked
in C.-a It doesn't work in C, however - this is one of many reasons why
I usually work in C++ rather than C.)
OK. Another reason why such things are not a priority in C. You either
use workarounds with macros or switch to a sister language which has
evolved much more dramatically.
In the language or compiler? Because machinery can be added to C too.
In C++, "s = { 10, 20 };" is valid because "{ 10, 20 }" is treated
as type std::initializer_list<int> (the "int" part is automatically
inferred).-a Making this work involves quite a bit of additional C++
machinery that does not exist in C.
std::initializer_list is a template.-a Making templates work in C would
require so many changes that it would be pointless - just use C++.
Maybe the assignment could be made to work in other ways that could be
more feasible to add to C.-a It's not something I have thought through
in detail.
On 02/11/2026 20:29, David Brown wrote:
On 02/11/2026 19:47, bartc wrote:
On 02/11/2026 16:36, David Brown wrote:
On 01/11/2026 14:41, bartc wrote:
On 01/11/2026 13:32, fir wrote:
it is maybe banal but sometimes banal remarks also maybe should be >>>>>> stated as i dont remember if i even was posting on that
the fact stat some cannot assign a structure like
this
s = {x,y};
seems rather silly (especially as structures can be assigned/copied) >>>>>>
with this {0,0,1} at least c has a basic of ths vector/tupple support >>>>>> and this 'native' support is quite standable..so its very weird it >>>>>> is 'blocked' from usage
#include <stdio.h>
typedef struct {int x,y;} T;
int main(void) {
-a-a-a-a T s;
-a-a-a-a s = (T){10,20};
}
As often seems to be the case, things Fir wants are already
available in C++.
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal.-a The expression "{ 10, 20 }" on
its own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
I think this has been discussed recently but I can't remember the
arguments.
But people can write:
-a-a-a x = 0;
and the exact type of '0' can be determined from the type of 'x', so
I don't see much difference.
No, 0 is of type "int".-a As an integer constant expression with value
0, it can be /converted/ to any pointer type, giving a null pointer
constant.-a It can also be converted to a float, or other arithmetic
type.-a But as it stands, "0" has a fixed type - "int".
Same thing. Here there is a tuple of two ints. (The syntax might be problematical in C outside of initialisation or following a cast.)
Such tuples can be used without having to expose them in the language.
They already occur here: (T){10, 20}.
Plus it doesn't see to be a problem here:
-a-a T s = {10, 20};
What determines the type of {10, 20} in this case?
That is initialisation, which is a different matter.-a Critically, it
is a declaration and not an expression - it does not produce a value
that can itself be used.
But it manages to figure out the types. (Even if it is not fussy about nested {} grouping.)
(I'd be happy if assignment were a particular kind of statement,
rather than an expression.-a I'd be happy if "s = { 10, 20 };" worked
in C.-a It doesn't work in C, however - this is one of many reasons why
I usually work in C++ rather than C.)
OK. Another reason why such things are not a priority in C. You either
use workarounds with macros or switch to a sister language which has
evolved much more dramatically.
In the language or compiler? Because machinery can be added to C too.
In C++, "s = { 10, 20 };" is valid because "{ 10, 20 }" is treated
as type std::initializer_list<int> (the "int" part is automatically
inferred).-a Making this work involves quite a bit of additional C++
machinery that does not exist in C.
std::initializer_list is a template.-a Making templates work in C would
require so many changes that it would be pointless - just use C++.
Maybe the assignment could be made to work in other ways that could be
more feasible to add to C.-a It's not something I have thought through
in detail.
(It seems to work in my language, provided the expression isn't 'open'.
So 'a := (x, y)' will work, as the LHS helps refine the type, but not
'print (x, y)' because the types have not been pinned down.)
David Brown <david.brown@hesbynett.no> writes:
[...]
In C, you need to give a type to "{ 10, 20 }" - as you did here,
making it into a compound literal. The expression "{ 10, 20 }" on its
own cannot be used for assignment to "s" because the type of an
expression must be determined from the expression alone - not from
what you are assigning it to.
In fact `{ 10, 20 }` is not an expression at all. It's a valid
initializer and it can be part of an expression (a compound literal).
(It seems to work in my language, provided the expression isn't 'open'.
So 'a := (x, y)' will work, as the LHS helps refine the type, but not
'print (x, y)' because the types have not been pinned down.)
zoo({x,y,} foo({2,3,4}))
foo terurns int-int-int but zoo takes only 2 ints
bartc pisze:
On 01/11/2026 13:32, fir wrote:
(It seems to work in my language, provided the expression isn'tthe fact stat some cannot assign a structure like
this
s = {x,y};
'open'. So 'a := (x, y)' will work, as the LHS helps refine the type,
but not 'print (x, y)' because the types have not been pinned down.)
[legal note:
imo if you take some ideas from me you should credit it (its like "i
seen it from the fir "or "as fir said/showed") ..im here speaking
generally becouse (i cant find as a copyright police what people took
for me and what by the chance no)
i know people are not much honest
anyway..yet this above is quite not so totally unusual observation
(though many undable to dat obeservations) but speaking generally]
same way {1,2,"assas", 8.9} is value of anonymous structure of type int
int char* double (or eventually float)
no any problem with that imo
On 03/11/2026 12:19, fir wrote:
bartc pisze:
On 01/11/2026 13:32, fir wrote:
(It seems to work in my language, provided the expression isn'tthe fact stat some cannot assign a structure like
this
s = {x,y};
'open'. So 'a := (x, y)' will work, as the LHS helps refine the type,
but not 'print (x, y)' because the types have not been pinned down.)
[legal note:
imo if you take some ideas from me you should credit it (its like "i
seen it from the fir "or "as fir said/showed") ..im here speaking
generally becouse (i cant find as a copyright police what people took
for me and what by the chance no)
You think I stole this 'feature' from your recent post?
In the early 1990s I could write code like this in my scripting language:
-a-a-a p := (100, 200, 300)
-a-a-a q := (20, 30, 40)
-a-a-a m := (p + q) / 2
-a-a-a println m-a-a-a-a-a-a-a-a-a-a # (60.00, 115.00, 170.00)
It was a 3D graphics application.
In my systems language, it worked like this, and from the 1980s:
-a-a record point =
-a-a-a-a-a-a int x, y
-a-a end
-a-a point p = (100, 200)-a-a-a-a-a-a-a-a # RHS must be compile-time expr
But general assignments, outside of initialisation and with runtime expressions, were not implemented until within the last decade (I can't remember exactly as I rarely use the feature, but it was more than two
days ago). That means being able to do this:
-a-a p := (x+1, y)
Such an ability is a natural consequence of the syntax which has always
been able to express it. It's just a question of (1) whether it has
useful and desirable semantics; (2) someone has bothered to implement it.
So it has been a thing since the 1980s, and I eventually got around to
it some decades later.
Notice also that it uses round brackets and not braces.
i know people are not much honest
anyway..yet this above is quite not so totally unusual observation
(though many undable to dat obeservations) but speaking generally]
Yeah, nobody has thought of having a constructor term like (a, b, c) in
a PL before you brought it up! Not even in Lisp.
Anyway, DB mentions that C++ has it in the form of {a, b, c}.
same way {1,2,"assas", 8.9} is value of anonymous structure of type
int int char* double (or eventually float)
no any problem with that imo
How do you access the elements?
On 03/11/2026 12:19, fir wrote:
bartc pisze:
On 01/11/2026 13:32, fir wrote:
(It seems to work in my language, provided the expression isn'tthe fact stat some cannot assign a structure like
this
s = {x,y};
'open'. So 'a := (x, y)' will work, as the LHS helps refine the type,
but not 'print (x, y)' because the types have not been pinned down.)
[legal note:
imo if you take some ideas from me you should credit it (its like "i
seen it from the fir "or "as fir said/showed") ..im here speaking
generally becouse (i cant find as a copyright police what people took
for me and what by the chance no)
You think I stole this 'feature' from your recent post?
In the early 1990s I could write code like this in my scripting language:
-a-a-a p := (100, 200, 300)
-a-a-a q := (20, 30, 40)
-a-a-a m := (p + q) / 2
-a-a-a println m-a-a-a-a-a-a-a-a-a-a # (60.00, 115.00, 170.00)
It was a 3D graphics application.
In my systems language, it worked like this, and from the 1980s:
-a-a record point =
-a-a-a-a-a-a int x, y
-a-a end
-a-a point p = (100, 200)-a-a-a-a-a-a-a-a # RHS must be compile-time expr
But general assignments, outside of initialisation and with runtime expressions, were not implemented until within the last decade (I can't remember exactly as I rarely use the feature, but it was more than two
days ago). That means being able to do this:
-a-a p := (x+1, y)
Such an ability is a natural consequence of the syntax which has always
been able to express it. It's just a question of (1) whether it has
useful and desirable semantics; (2) someone has bothered to implement it.
So it has been a thing since the 1980s, and I eventually got around to
it some decades later.
Notice also that it uses round brackets and not braces.
i know people are not much honest
anyway..yet this above is quite not so totally unusual observation
(though many undable to dat obeservations) but speaking generally]
Yeah, nobody has thought of having a constructor term like (a, b, c) in
a PL before you brought it up! Not even in Lisp.
Anyway, DB mentions that C++ has it in the form of {a, b, c}.
same way {1,2,"assas", 8.9} is value of anonymous structure of type
int int char* double (or eventually float)
no any problem with that imo
How do you access the elements?
fir pisze:
zoo({x,y,} foo({2,3,4}))
foo terurns int-int-int but zoo takes only 2 ints
it shows some interesting thing like
x = foo() this equal could be said is wrong (becouse it is not
quite assigment in general its like adressing x more than assigning)
becouse here it could be
{x} foo()
or
-afoo(){x}
(it also may be kipped as anonymous as it is often skipped )
its also more compatible as i asid in returning more values
buck then i was thinking about shipping {} and use this pure form
like x y foo a b c but it seem harder to think so for some stage this
very classic {a,b,c} is quite good to do some insight using it
fir pisze:
fir pisze:
zoo({x,y,} foo({2,3,4}))
foo terurns int-int-int but zoo takes only 2 ints
it shows some interesting thing like
x = foo() this equal could be said is wrong (becouse it is not
quite assigment in general its like adressing x more than assigning)
becouse here it could be
{x} foo()
or
-a-afoo(){x}
i dont know it this above is in fact not more basic than this leftside one
generally some coud say that calling coud work both left and right
then () would be operator of taking ad {} of returning
(3,4) add-a {c} //add 3 yo 4 and put it to c
or for both sides
(2) add (3) {c}
i dont know if it has sense but something could be searched here
(as to potential usability)
(it also may be kipped as anonymous as it is often skipped )
its also more compatible as i asid in returning more values
buck then i was thinking about shipping {} and use this pure form
like x y foo a b c but it seem harder to think so for some stage this
very classic {a,b,c} is quite good to do some insight using it
fir pisze:
fir pisze:
fir pisze:
zoo({x,y,} foo({2,3,4}))
foo terurns int-int-int but zoo takes only 2 ints
it shows some interesting thing like
x = foo() this equal could be said is wrong (becouse it is not
quite assigment in general its like adressing x more than assigning)
becouse here it could be
{x} foo()
or
-a-afoo(){x}
i dont know it this above is in fact not more basic than this leftside
one
generally some coud say that calling coud work both left and right
then () would be operator of taking ad {} of returning
(3,4) add-a {c} //add 3 yo 4 and put it to c
or for both sides
(2) add (3) {c}
a sto "pure form" (or normally speaking pure form) overally it seems
that those () {} can be ommited in call when function has very hardcoded signature, so eventually you may add some in definition to hardcode such signature
(int a) (int b) foo [int x]
{
-a-a x = a + b
}
than
2 3 add b
is know what mean
maybe this pure form is in fact better becouse its clarity is appealing
i dont know if it has sense but something could be searched here
(as to potential usability)
(it also may be kipped as anonymous as it is often skipped )
its also more compatible as i asid in returning more values
buck then i was thinking about shipping {} and use this pure form
like x y foo a b c but it seem harder to think so for some stage this
very classic {a,b,c} is quite good to do some insight using it
On 03/11/2026 12:19, fir wrote:
bartc pisze:
On 01/11/2026 13:32, fir wrote:
(It seems to work in my language, provided the expression isn'tthe fact stat some cannot assign a structure like
this
s = {x,y};
'open'. So 'a := (x, y)' will work, as the LHS helps refine the type,
but not 'print (x, y)' because the types have not been pinned down.)
[legal note:
imo if you take some ideas from me you should credit it (its like "i
seen it from the fir "or "as fir said/showed") ..im here speaking
generally becouse (i cant find as a copyright police what people took
for me and what by the chance no)
You think I stole this 'feature' from your recent post?
In the early 1990s I could write code like this in my scripting language:
-a-a-a p := (100, 200, 300)
-a-a-a q := (20, 30, 40)
-a-a-a m := (p + q) / 2
-a-a-a println m-a-a-a-a-a-a-a-a-a-a # (60.00, 115.00, 170.00)
It was a 3D graphics application.
In my systems language, it worked like this, and from the 1980s:
-a-a record point =
-a-a-a-a-a-a int x, y
-a-a end
-a-a point p = (100, 200)-a-a-a-a-a-a-a-a # RHS must be compile-time expr
But general assignments, outside of initialisation and with runtime expressions, were not implemented until within the last decade (I can't remember exactly as I rarely use the feature, but it was more than two
days ago). That means being able to do this:
-a-a p := (x+1, y)
Such an ability is a natural consequence of the syntax which has always
been able to express it. It's just a question of (1) whether it has
useful and desirable semantics; (2) someone has bothered to implement it.
So it has been a thing since the 1980s, and I eventually got around to
it some decades later.
Notice also that it uses round brackets and not braces.
i know people are not much honest
anyway..yet this above is quite not so totally unusual observation
(though many undable to dat obeservations) but speaking generally]
Yeah, nobody has thought of having a constructor term like (a, b, c) in
a PL before you brought it up! Not even in Lisp.
Anyway, DB mentions that C++ has it in the form of {a, b, c}.
same way {1,2,"assas", 8.9} is value of anonymous structure of type
int int char* double (or eventually float)
no any problem with that imo
How do you access the elements?
note i notice you are like halfly wanted to be foaming foam man
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
whould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
You're trying to create a language syntax like monkeys typing at randomwhould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
You're trying to create a language syntax like monkeys typing at randomwhould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a forum
as this anyway?
Work it out privately and when you have something worth discussing then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are anywhere in this ballpark. Currently your musings are a million miles away.
bartc pisze:
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
in the hipermodular approach (which is proper stright approach, not some fancy imo) functions have properties of structures and structures have properties of functions
so if you have struct rand {int value} you may acces the rand.value
but also instead of struct rand you could have just rand (int rand)
so you may acces rand
so here
rand {int value = rand()}
some may use int x = rand();-a rand.value++; etc
with this syntax
int rand {rand = rand()}
you may use int x = rand(); rand++;
just ommiting this field named value but accesing this entity rand stright
You're trying to create a language syntax like monkeys typing atwhould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
random in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a forum
as this anyway?
Work it out privately and when you have something worth discussing
then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are
anywhere in this ballpark. Currently your musings are a million miles
away.
it is very worth discussing its just above your level..so i csuggest get
to work and learn up
fir pisze:
bartc pisze:instead of foaming...
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
in the hipermodular approach (which is proper stright approach, not
some fancy imo) functions have properties of structures and structures
have properties of functions
so if you have struct rand {int value} you may acces the rand.value
but also instead of struct rand you could have just rand (int rand)
so you may acces rand
so here
rand {int value = rand()}
some may use int x = rand();-a rand.value++; etc
with this syntax
int rand {rand = rand()}
you may use int x = rand(); rand++;
just ommiting this field named value but accesing this entity rand
stright
You're trying to create a language syntax like monkeys typing atwhould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
random in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a
forum as this anyway?
Work it out privately and when you have something worth discussing
then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are
anywhere in this ballpark. Currently your musings are a million miles
away.
it is very worth discussing its just above your level..so i csuggest
get to work and learn up
bartc pisze:
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
in the hipermodular approach (which is proper stright approach, not some fancy imo) functions have properties of structures and structures have properties of functions
so if you have struct rand {int value} you may acces the rand.value
but also instead of struct rand you could have just rand (int rand)
so you may acces rand
so here
rand {int value = rand()}
some may use int x = rand();-a rand.value++; etc
with this syntax
int rand {rand = rand()}
you may use int x = rand(); rand++;
just ommiting this field named value but accesing this entity rand stright
You're trying to create a language syntax like monkeys typing atwhould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
random in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a forum
as this anyway?
Work it out privately and when you have something worth discussing
then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are
anywhere in this ballpark. Currently your musings are a million miles
away.
it is very worth discussing its just above your level..so i csuggest get
to work and learn up
fir pisze:
bartc pisze:overally i remember i was not quite sure how to define operators in c
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
in the hipermodular approach (which is proper stright approach, not
some fancy imo) functions have properties of structures and structures
have properties of functions
so if you have struct rand {int value} you may acces the rand.value
but also instead of struct rand you could have just rand (int rand)
so you may acces rand
so here
rand {int value = rand()}
some may use int x = rand();-a rand.value++; etc
with this syntax
int rand {rand = rand()}
you may use int x = rand(); rand++;
just ommiting this field named value but accesing this entity rand
stright
but its probably like this:
some(int a)-a-a-a-a-a-a //some module
{
-ax++, y +=a, z=a-a-a-a-a-a-a-a-a-a-a-a-a-a //some code
-aint x y z-a // fields
-afoo (int x) {} //function definition
-a!(int x) {printf("%d", x)} //operator definition
-a(int x) %% (int y) {} //operator definition
}
//usage
some(4) //calls code
some-a //has value of x y z
foo(2) //calls foo
!23 //printfs 23
6%%3 //calls operator code
so its ratcher clear, some may think if to not omit some ()
in this definition here but for clarity here its stays
in fact it dont seem tu be much doubtfull at least at some level
here and it showed most strightforward
there is no differentiation on read only and readwrite or write only arguments but in some way this is not needed as code
inside function or operator sjhows if it is read written or read and
written
if someone would like to define basic operators liek + *
its maybe also possible but there would need to be added some
hook into assembly
You're trying to create a language syntax like monkeys typing atwhould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
random in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a
forum as this anyway?
Work it out privately and when you have something worth discussing
then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are
anywhere in this ballpark. Currently your musings are a million miles
away.
it is very worth discussing its just above your level..so i csuggest
get to work and learn up
fir pisze:
fir pisze:
bartc pisze:overally i remember i was not quite sure how to define operators in c
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
in the hipermodular approach (which is proper stright approach, not
some fancy imo) functions have properties of structures and
structures have properties of functions
so if you have struct rand {int value} you may acces the rand.value
but also instead of struct rand you could have just rand (int rand)
so you may acces rand
so here
rand {int value = rand()}
some may use int x = rand();-a rand.value++; etc
with this syntax
int rand {rand = rand()}
you may use int x = rand(); rand++;
just ommiting this field named value but accesing this entity rand
stright
but its probably like this:
some(int a)-a-a-a-a-a-a //some module
{
-a-ax++, y +=a, z=a-a-a-a-a-a-a-a-a-a-a-a-a-a //some code
-a-aint x y z-a // fields
-a-afoo (int x) {} //function definition
-a-a!(int x) {printf("%d", x)} //operator definition
-a-a(int x) %% (int y) {} //operator definition
}
note (though i already was talkin on it i will yet repeat it)
this above may seem obvious - after you seen it - BUT BEFORE it was
far from obvious - how far? you would take a long route with some non
binary decisions and observations..where this route is more like 50
important decisions/observations than 5 and thoce decisions are also not binary (though i dont know how to some could express it as a number but
for some ilustration if some could name this number by M and this
decison route length by 50 then the final result was like one from 50^M
(this is ofc some simplification but it imo ilustrates something)
so as to "stealing" its very easy to steal this - it is also very easy
to say its obvious and ignoring the long route here (and if something is eassy i may suspect people could do that eventually (i hope no but theoretically its possible - unfortunatelly..stealing it could involve lie'ing (laying?) so maybe it will not happen - besides not much people
are interested in that and maybe its good as im still working on that
(though some work or at least "intermediate work" here may be also seen
as a complete)
//usage
some(4) //calls code
some-a //has value of x y z
foo(2) //calls foo
!23 //printfs 23
6%%3 //calls operator code
so its ratcher clear, some may think if to not omit some ()
in this definition here but for clarity here its stays
in fact it dont seem tu be much doubtfull at least at some level
here and it showed most strightforward
there is no differentiation on read only and readwrite or write only
arguments but in some way this is not needed as code
inside function or operator sjhows if it is read written or read and
written
if someone would like to define basic operators liek + *
its maybe also possible but there would need to be added some
hook into assembly
You're trying to create a language syntax like monkeys typing atwhould be probably present as modules just have its options to be >>>>>> written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty) >>>>>>
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking >>>>>> output values?
{X} rand
rand {x}
i dont know yet
random in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a
forum as this anyway?
Work it out privately and when you have something worth discussing
then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are
anywhere in this ballpark. Currently your musings are a million
miles away.
it is very worth discussing its just above your level..so i csuggest
get to work and learn up
fir pisze:
bartc pisze:overally i remember i was not quite sure how to define operators in c
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
in the hipermodular approach (which is proper stright approach, not
some fancy imo) functions have properties of structures and structures
have properties of functions
so if you have struct rand {int value} you may acces the rand.value
but also instead of struct rand you could have just rand (int rand)
so you may acces rand
so here
rand {int value = rand()}
some may use int x = rand();-a rand.value++; etc
with this syntax
int rand {rand = rand()}
you may use int x = rand(); rand++;
just ommiting this field named value but accesing this entity rand
stright
but its probably like this:
some(int a)-a-a-a-a-a-a //some module
{
-ax++, y +=a, z=a-a-a-a-a-a-a-a-a-a-a-a-a-a //some code
-aint x y z-a // fields
-afoo (int x) {} //function definition
-a!(int x) {printf("%d", x)} //operator definition
-a(int x) %% (int y) {} //operator definition
}
//usage
some(4) //calls code
some-a //has value of x y z
foo(2) //calls foo
!23 //printfs 23
6%%3 //calls operator code
so its ratcher clear, some may think if to not omit some ()
in this definition here but for clarity here its stays
in fact it dont seem tu be much doubtfull at least at some level
here and it showed most strightforward
there is no differentiation on read only and readwrite or write only arguments but in some way this is not needed as code
inside function or operator sjhows if it is read written or read and
written
if someone would like to define basic operators liek + *
its maybe also possible but there would need to be added some
hook into assembly
You're trying to create a language syntax like monkeys typing atwhould be probably present as modules just have its options to be
written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty)
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking
output values?
{X} rand
rand {x}
i dont know yet
random in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a
forum as this anyway?
Work it out privately and when you have something worth discussing
then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are
anywhere in this ballpark. Currently your musings are a million miles
away.
it is very worth discussing its just above your level..so i csuggest
get to work and learn up
fir pisze:
fir pisze:
bartc pisze:overally i remember i was not quite sure how to define operators in c
On 03/11/2026 16:06, fir wrote:
fir pisze:
fir pisze:
output one also can be defined like here
rand (int d) [int x] { x = rand()%d}
rand 10 x
my hiper modular thinking i was doin back then suggest that
both forms i mean
rand {int value = rand()}
rand [int value] {value = rand()}
there is also option
int rand { rand = rand()}
Which means...?
in the hipermodular approach (which is proper stright approach, not
some fancy imo) functions have properties of structures and
structures have properties of functions
so if you have struct rand {int value} you may acces the rand.value
but also instead of struct rand you could have just rand (int rand)
so you may acces rand
so here
rand {int value = rand()}
some may use int x = rand();-a rand.value++; etc
with this syntax
int rand {rand = rand()}
you may use int x = rand(); rand++;
just ommiting this field named value but accesing this entity rand
stright
but its probably like this:
some(int a)-a-a-a-a-a-a //some module
{
-a-ax++, y +=a, z=a-a-a-a-a-a-a-a-a-a-a-a-a-a //some code
-a-aint x y z-a // fields
-a-afoo (int x) {} //function definition
-a-a!(int x) {printf("%d", x)} //operator definition
-a-a(int x) %% (int y) {} //operator definition
}
//usage
some(4) //calls code
some-a //has value of x y z
foo(2) //calls foo
!23 //printfs 23
6%%3 //calls operator code
so its ratcher clear, some may think if to not omit some ()
in this definition here but for clarity here its stays
in fact it dont seem tu be much doubtfull at least at some level
here and it showed most strightforward
there is no differentiation on read only and readwrite or write only
arguments but in some way this is not needed as code
inside function or operator sjhows if it is read written or read and
written
if someone would like to define basic operators liek + *
its maybe also possible but there would need to be added some
hook into assembly
it is open question how to "define" int in extended c (xc, maybe i
should use abbreviations extended c is xc deep c is dc and so on)
i could think about something like that at start but it needs
more thinking and im weary today but it may be some start
int {
-a-a-a-a __asm_i32 value;
-a-a-a-a (int a)=(int b)
-a-a-a-a {
-a-a-a-a-a-a _asm mov a b
-a-a-a-a }
-a-a-a-a (int a)+(int b)
-a-a-a-a {
-a-a-a-a-a-a int c;
-a-a-a-a-a-a _asm mov register a
-a-a-a-a-a-a _asm_add register b
-a-a-a-a-a-a _asm mov c register
-a-a-a-a }
-a-a-a-a (int a)-(int b)
-a-a-a-a {
-a-a-a-a-a-a int c;
-a-a-a-a-a-a _asm mov register a
-a-a-a-a-a-a _asm_sub register b
-a-a-a-a-a-a _asm mov c register
-a-a-a-a }
-a-a-a-a (int a)*(int b)
-a-a-a-a {
-a-a-a-a-a-a int c;
-a-a-a-a-a-a _asm mov register a
-a-a-a-a-a-a _asm_mul register b
-a-a-a-a-a-a _asm mov c register
-a-a-a-a }
-a-a-a-a (int a)/(int b)
-a-a-a-a {
-a-a-a-a-a-a int c;
-a-a-a-a-a-a _asm mov register a
-a-a-a-a-a-a _asm_div register b
-a-a-a-a-a-a _asm mov c register
-a-a-a-a }
}
then
int x = a*b+c/d-e
would-a just yeild to sequential calls
=(x,(-(/(+(*(a,b),c),d),e)))
should it work?
to weary to check
You're trying to create a language syntax like monkeys typing atwhould be probably present as modules just have its options to be >>>>>> written and those are two realisations of those options
first has just ownning his ovn ram and second not (bein ram empty) >>>>>>
now what has {} to do with it?
hela know
maybe it should work like a cast orr just be and option of marking >>>>>> output values?
{X} rand
rand {x}
i dont know yet
random in the hope they'll produce some Shakespeare.
What the hell are you doing spouting all this nonsense in such a
forum as this anyway?
Work it out privately and when you have something worth discussing
then maybe post to a relevant group, if sticking with usenet.
But I'd suggest not bothering with comp.lang.c unless your ideas are
anywhere in this ballpark. Currently your musings are a million
miles away.
it is very worth discussing its just above your level..so i csuggest
get to work and learn up
there is also option
int rand { rand = rand()}
Which means...?
there is also option
int rand { rand = rand()}
Which means...?
fir pisze:
there is also option
int rand { rand = rand()}
Which means...?
here not if-a its not clear this above is
rand-a //structure/module/function/type/namespace
{
-aint;-a //anonymous field
-a rand = rand();-a-a //code to call.. as int is anonymous use rand name
to assign rand function
}
here by rand i mean this rand from clib it maybe is confusing as its collision of names and here it would be simply like-a endless loop by mistake - int calling itself in a loop
some is structure but also may be use as 'type'
main()
{
-a some;
-a-a some.x = 10;
-a some a,b,c;
-a-a a.x = 10 ;
}
some {int}
//seems more logical than int some ..but here for historical reasons
"int some" may be used-a i think
there is also option
int rand { rand = rand()}
Which means...?
bartc pisze:
there is also option
int rand { rand = rand()}
Which means...?
check also this you got
-aa structure module
some
{
-a int x;
}
some is structure but also may be use as 'type'
main()
{
-a some;
-a-a some.x = 10;
-a some a,b,c;
-a-a a.x = 10 ;
}
now get an array of some
some[Y][X];
all a function part to it
some[Y][X] (int v)
{
-a int val;
-afor (int j=0; j<Y; j++}
-afor (int i=0; i<X; i++}
-a{
-a-a some[j][i].val = v;
-a}
}
some[100][100](3);
//creates table of 100x100 of some and calls on it so it feels up with 3
bartc pisze:
there is also option
int rand { rand = rand()}
Which means...?
ofc some could also write
int rand() { rand = rand()}
then its maybe easier to understtod..
note its not a function rand() that returns int its a module-function
rand tthat contains/covers int
i moit those empty () for function modules becouse they are not needed like
some {printf("\n elo";) }
On 07/11/2026 19:14, fir wrote:
bartc pisze:
there is also option
int rand { rand = rand()}
Which means...?
check also this you got
-a-aa structure module
some
{
-a-a int x;
}
some is structure but also may be use as 'type'
Well, those are the same thing.
main()
{
-a-a some;
Stop: what have you just declared here?
-a-a-a some.x = 10;
So now 'some' is a variable of type 'some'?
This is either nonsensical, or you've left something out or mixed
something up.
-a-a some a,b,c;
-a-a-a a.x = 10 ;
}
now get an array of some
some[Y][X];
all a function part to it
some[Y][X] (int v)
So, what is 'some' /now/?! Is is a function, type or variable? You know
it would be very easy to explain.
{
-a-a int val;
-a-afor (int j=0; j<Y; j++}
-a-afor (int i=0; i<X; i++}
-a-a{
-a-a-a some[j][i].val = v;
-a-a}
}
How does this code get invoked?
some[100][100](3);
//creates table of 100x100 of some and calls on it so it feels up with 3
OK. So you're calling a typespec.
Oh, I give up.
On 07/11/2026 19:50, fir wrote:
bartc pisze:
there is also option
int rand { rand = rand()}
Which means...?
ofc some could also write
int rand() { rand = rand()}
One could also avoid using the same identifier for three different things!
I assume that last 'rand' is calling some external function, but that is going to be shadowed by at least that first 'rand' and possibly the second.
then its maybe easier to understtod..
No, try it like this first:
-a int A() {B = C()}
Although that will only fix one puzzle out of many.
note its not a function rand() that returns int its a module-function
rand tthat contains/covers int
i moit those empty () for function modules becouse they are not needed
like
some {printf("\n elo";) }
'some' seems to be a refugee from your other post. It's not defined here anyway.
No, try it like this first:
-a-a int A() {B = C()}
fir pisze:
No, try it like this first:
-a-a-a int A() {B = C()}
no this should be
-a int A() {A = C()}
now its ok
if
C(){2}-a //in clasic c its colose to int C() {return 2}
then
A()
calls C() and assigns 2 to A so A is 2 now
or take it
-aint A(int B) {A = C()*B}
A(3) assigns 6 to a so
main:
C{2} //modue with value 2
int A(int B) {A = C()*B}-a //module A definition
A(10)-a //asigns-a 20 to A
int X = A*A;-a //assigns 400 to X
in fact tha call C() is ignored as there is no code to execute in C-a but
C value is taken
fir pisze:
fir pisze:
there is also option
int rand { rand = rand()}
Which means...?
here not if-a its not clear this above is
rand-a //structure/module/function/type/namespace
{
-a-aint;-a //anonymous field
-a-a rand = rand();-a-a //code to call.. as int is anonymous use rand name >> to assign rand function
}
here by rand i mean this rand from clib it maybe is confusing as its
collision of names and here it would be simply like-a endless loop by
mistake - int calling itself in a loop
good raa huuh?
i personally like it though i dont yet observed all options here
fir pisze:
No, try it like this first:
-a-a-a int A() {B = C()}
no this should be
-a int A() {A = C()}
now its ok
if
C(){2}-a //in clasic c its colose to int C() {return 2}
then
A()
calls C() and assigns 2 to A so A is 2 now
or take it
-aint A(int B) {A = C()*B}
A(3) assigns 6 to a so
On 08/11/2026 03:36, fir wrote:
fir pisze:
No, try it like this first:
-a-a-a int A() {B = C()}
no this should be
-a-a int A() {A = C()}
now its ok
if
C(){2}-a //in clasic c its colose to int C() {return 2}
So C is a function name, and 'C(){2}' (which seems to be something new) defines that function to return '2' with a type of 'int'?
then
A()
calls C() and assigns 2 to A so A is 2 now
And A is ... a variable? A function? An alias for function C? An alias
for whatever C happens to return?
Forget C, this is one of best esolangs I've seen described. But this is
the wrong forum for it.
or take it
-a-aint A(int B) {A = C()*B}
A(3) assigns 6 to a so
Are these higher-order functions, so that calling A() returns a new
function (a closure in this case)?
In that case you're calling it wrong. You need:
-a-a-a F = A(3)-a-a-a-a-a-a-a-a # generate a new function equivalent to C()*3
-a-a-a F()-a-a-a-a-a-a-a-a-a-a-a-a-a # returns C()*3
But this is more interesting when F takes an argument too.
So you've just discovered functional programming. But then, most of this stuff I believe is already possible in C++, if you were to learn it properly.
C ad A arestructures and functions-a at once
C() {2}-a (Or
C{2} is the same as you may skip () in definiton if they are empty)
fir pisze:
C ad A arestructures and functions-a at once
C() {2}-a (Or
C{2} is the same as you may skip () in definiton if they are empty)
note normally it could be defined
int C() {C=2}
so now when you write
printf("%d", C*C);
then C may be not set it rather printf 0 or random stack value
but the
C{2}
is a nice shortcut also
those are all discovered ideas and some details i mat yet all change
as those dicoveries open some space for some decisions
fir pisze:
fir pisze:
C ad A arestructures and functions-a at once
C() {2}-a (Or
C{2} is the same as you may skip () in definiton if they are empty)
note normally it could be defined
int C() {C=2}
so now when you write
printf("%d", C*C);
then C may be not set it rather printf 0 or random stack value
but the
C{2}
is a nice shortcut also
those are all discovered ideas and some details i mat yet all change
as those dicoveries open some space for some decisions
I could say its not concise becuse say you got such
int C {clib_rand()}
now C() calls clib_rand() but discards a value
and C as value has unset int value even after C() call
(and its possibly somewhat good)
so
C{2} whan called C() should do nothing (ass calling 2; do nothing)
but as read should not have a value (not 2) but C{2} seem nice to have
as 2 so maybe it needs to have some additional rules to define or change
the above
putting the rule that
C{} should have value of what inside has as value is not quite good
becouse say
C(int i) {i++; i++; i++; i++; -1,0,-4}
would have 'volatile' value-a like {2,3,4,5, -1,0,4}-a which seem kinda nonsence (in some way)
i dont know maybe just code lines could be skipped so in the above
C has a value of {-1,0,4}
(and in those all things i wrote before it was kinda ssumed in facy
(though in fact i was not considered constants there)
fir pisze:
fir pisze:
No, try it like this first:
-a-a-a int A() {B = C()}
no this should be
-a-a int A() {A = C()}
now its ok
if
C(){2}-a //in clasic c its colose to int C() {return 2}
then
A()
calls C() and assigns 2 to A so A is 2 now
or take it
-a-aint A(int B) {A = C()*B}
A(3) assigns 6 to a so
main:
C{2} //modue with value 2
int A(int B) {A = C()*B}-a //module A definition
A(10)-a //asigns-a 20 to A
int X = A*A;-a //assigns 400 to X
if you dont understand it its like
-a-a sinf(); ///calls sinf() function but the result is not 'returned'
but its a float named sinf
sou you can
-a-a sinf(1.22);
float a = sinf*20;
and in sinf definition you use this syntax
float sinf(float a)
{
-a-a-a //do calculations here
-a-a-a sinf = //..... result
}
so
int rand { rand = clib_rand()}
then rand() //cals rand
a = rand*rand-a //uses value (witthout calling
a = rand()*rand
in fact tha call C() is ignored as there is no code to execute in C
but C value is taken
fir pisze:
fir pisze:
fir pisze:
No, try it like this first:
-a-a-a int A() {B = C()}
no this should be
-a-a int A() {A = C()}
now its ok
if
C(){2}-a //in clasic c its colose to int C() {return 2}
then
A()
calls C() and assigns 2 to A so A is 2 now
or take it
-a-aint A(int B) {A = C()*B}
A(3) assigns 6 to a so
main:
C{2} //modue with value 2
int A(int B) {A = C()*B}-a //module A definition
A(10)-a //asigns-a 20 to A
int X = A*A;-a //assigns 400 to X
if you dont understand it its like
-a-a-a sinf(); ///calls sinf() function but the result is not 'returned'
but its a float named sinf
sou you can
-a-a-a sinf(1.22);
float a = sinf*20;
and in sinf definition you use this syntax
float sinf(float a)
{
-a-a-a-a //do calculations here
-a-a-a-a sinf = //..... result
}
so
int rand { rand = clib_rand()}
then rand() //cals rand
a = rand*rand-a //uses value (witthout calling
here above you could
a = rand()*rand
calls rand and squares it //like 22*22
a = rand()*rand()
calls rand twice //like 348*982
a = rand*rand() //uses previous rand and calls rand //like 982 *1342
all this sintax is much more capacious so you could write more heavy (condensed) code
On 08/11/2026 15:20, fir wrote:
fir pisze:
fir pisze:
fir pisze:
No, try it like this first:
-a-a-a int A() {B = C()}
no this should be
-a-a int A() {A = C()}
now its ok
if
C(){2}-a //in clasic c its colose to int C() {return 2}
then
A()
calls C() and assigns 2 to A so A is 2 now
or take it
-a-aint A(int B) {A = C()*B}
A(3) assigns 6 to a so
main:
C{2} //modue with value 2
int A(int B) {A = C()*B}-a //module A definition
A(10)-a //asigns-a 20 to A
int X = A*A;-a //assigns 400 to X
if you dont understand it its like
-a-a-a sinf(); ///calls sinf() function but the result is not 'returned' >>> but its a float named sinf
sou you can
-a-a-a sinf(1.22);
float a = sinf*20;
and in sinf definition you use this syntax
float sinf(float a)
{
-a-a-a-a //do calculations here
-a-a-a-a sinf = //..... result
}
so
int rand { rand = clib_rand()}
then rand() //cals rand
a = rand*rand-a //uses value (witthout calling
-a-a int randv;
-a-a int randf() {
-a-a-a-a-a-a randv = rand();-a-a // from stdlib.h
-a-a }
-a-a randf();-a-a-a-a-a-a-a-a-a-a-a-a-a // calls rand and store in randv
-a-a a = randv*randv;-a-a-a-a-a // uses value without calling
So this is nothing that can't be done now and much more clearly.
here above you could
a = rand()*rand
calls rand and squares it //like 22*22
OK, so:
-a-a a = rand()**2;
C doesn't have '**' now, but this is much more useful and general
purpose extension. Or you can emulate it:
-a-a int sqrint(int a) { return a * a;}
-a-a a = sqrint(rand());
Again, this can be done right now.
a = rand()*rand()
calls rand twice //like 348*982
a = rand*rand() //uses previous rand and calls rand //like 982 *1342
all this sintax is much more capacious so you could write more heavy
(condensed) code
Is that supposed to be good, or bad?
If less syntax is used it should be because of true simplicity not
because due to an incomprehensible set of language rules.
bartc pisze:
On 08/11/2026 15:20, fir wrote:
fir pisze:
fir pisze:
fir pisze:
No, try it like this first:
-a-a-a int A() {B = C()}
no this should be
-a-a int A() {A = C()}
now its ok
if
C(){2}-a //in clasic c its colose to int C() {return 2}
then
A()
calls C() and assigns 2 to A so A is 2 now
or take it
-a-aint A(int B) {A = C()*B}
A(3) assigns 6 to a so
main:
C{2} //modue with value 2
int A(int B) {A = C()*B}-a //module A definition
A(10)-a //asigns-a 20 to A
int X = A*A;-a //assigns 400 to X
if you dont understand it its like
-a-a-a sinf(); ///calls sinf() function but the result is not
'returned' but its a float named sinf
sou you can
-a-a-a sinf(1.22);
float a = sinf*20;
and in sinf definition you use this syntax
float sinf(float a)
{
-a-a-a-a //do calculations here
-a-a-a-a sinf = //..... result
}
so
int rand { rand = clib_rand()}
then rand() //cals rand
a = rand*rand-a //uses value (witthout calling
-a-a-a int randv;
-a-a-a int randf() {
-a-a-a-a-a-a-a randv = rand();-a-a // from stdlib.h
-a-a-a }
-a-a-a randf();-a-a-a-a-a-a-a-a-a-a-a-a-a // calls rand and store in randv >>
-a-a-a a = randv*randv;-a-a-a-a-a // uses value without calling
So this is nothing that can't be done now and much more clearly.
here above you could
a = rand()*rand
calls rand and squares it //like 22*22
OK, so:
-a-a-a a = rand()**2;
C doesn't have '**' now, but this is much more useful and general
purpose extension. Or you can emulate it:
-a-a-a int sqrint(int a) { return a * a;}
-a-a-a a = sqrint(rand());
Again, this can be done right now.
a = rand()*rand()
calls rand twice //like 348*982
a = rand*rand() //uses previous rand and calls rand //like 982 *1342
all this sintax is much more capacious so you could write more heavy
(condensed) code
Is that supposed to be good, or bad?
If less syntax is used it should be because of true simplicity not
because due to an incomprehensible set of language rules.
you could say the same when you learned c first time
in fact learning this above is like learning c first time, you should be happy
it also shows that oryginal c and those upbildings are close, its close feeling of having more c in c
ofc the fact you can write more heavy C is considereg good -
it is considered very good
i probbaly could find more examles of this heavier c be heavier
(thus shorted) than oryginal c but i would probbaly be in mood to think up examples...you may also try yourself
(i will tray to give such examples but in some future yet not
know when i will be in proper mood .. right now im feeling a bit tired
ans sleepy ;c)
also such form is generally nice
foo{
-a aaa{
-a-a-a bb{}
-a-a }
-a zoo{}
booo{}
}
what is this? functions containing functions and at onece
modules/structures containing structures depending if you put data
inside or code inside
its answered itself so it can be said its answered (what it is)
yet maybe some thoughts on for loop syntax potential improvements
im really annoyed by long c loops
like for(int i=0; i<100; i++) {}
back hen i miraculously mabe found some good alternative but it needs
unicode
100EYEo {}-a //is alternative for "for(int i=0; i<100; i++) {}"
it needs unicode becouse you will need tu use varable here
and if you use variable then normal i would be part of name of the variable
widthEYEo {} //bold or cursive (italics) for indexes
eventualy some culd use greek letters etc
A-e tab[-e]=9
(eventually though amybe less likely A-e: tab[-e]=9-a )
lookin good but may have some drawbacks like its quite strong decision
overally i thinked what WOULD look the natural form of loop in c
in my mind appeared today some:
if f() is a function call then
f();f();f();f();f();f();f();f();
resembles loop thus
f()^10 may be understand as a kinda "natural" form of loop
so
int i =0; {a[i++]==0? break} ^ strlen(a);
might be seen as kinda natural
(probably thought here strlen would be called many tiles so maybe
int LEN = strlen(a);
int i =0; {a[i++]==0? break} ^ LEN;
its not bad still its a bit long, has no shorter form and also
there is a problem power has no leftsde form like 2^10 has not a form
"10th power of 2" though maybe some could vrite ^10 {2}
so some shortcut form i could consider
i^100 {tab[i]=0}
its not quite as natural as-a {tab[i++]=0}^100 but maybe its standable as its based on idea of power and adds some to it
i even noticed this sole sign "^" could be read as "for"
i^100 would mean power given block-a 100 times and i treat as a number of this powering
i^10..99 { tab[i] = 0; }
( or { tab[i] = 0; } i^10..99 )
would then mean for i from 10 to 99 (inclusively)
im not sure if this is enough good but those-a two syntaxes
(one using this unicode indexes in minimal form) and this based on
ascii is what i'm about currently
some could be worried that now this i as index is not an "int i"
only enigmatic i - but im not sure if such special thing as index of the loop (which is kinda low level thing should be necessary a clasical int i..maybe it shouldnt?
yet maybe some thoughts on for loop syntax potential improvements
im really annoyed by long c loops
like for(int i=0; i<100; i++) {}
back hen i miraculously mabe found some good alternative but it needs
unicode
100EYEo {}-a //is alternative for "for(int i=0; i<100; i++) {}"
if f() is a function call then
f();f();f();f();f();f();f();f();
resembles loop thus
f()^10 may be understand as a kinda "natural" form of loop
so
int i =0; {a[i++]==0? break} ^ strlen(a);
might be seen as kinda natural
(probably thought here strlen would be called many tiles so maybe
int LEN = strlen(a);
int i =0; {a[i++]==0? break} ^ LEN;
its not bad still its a bit long, has no shorter form and also
there is a problem power has no leftsde form like 2^10 has not a form
"10th power of 2" though maybe some could vrite ^10 {2}
so some shortcut form i could consider
i^100 {tab[i]=0}
its not quite as natural as-a {tab[i++]=0}^100 but maybe its standable as
its based on idea of power and adds some to it
i even noticed this sole sign "^" could be read as "for"
i^100 would mean power given block-a 100 times and i treat as a number of this powering
i^10..99 { tab[i] = 0; }
( or { tab[i] = 0; } i^10..99 )
im not sure if this is enough good but those-a two syntaxes
(one using this unicode indexes in minimal form) and this based on
ascii is what i'm about currently
some could be worried that now this i as index is not an "int i"
only enigmatic i - but im not sure if such special thing as index of the loop (which is kinda low level thing should be necessary a clasical int i..maybe it shouldnt?
On 09/11/2026 22:47, fir wrote:
yet maybe some thoughts on for loop syntax potential improvements
im really annoyed by long c loops
like for(int i=0; i<100; i++) {}
So am I.
back hen i miraculously mabe found some good alternative but it needs
unicode
But there are a million ways to have a shorter syntax without needing to resort to Unicode.
Have you looked at /any/ other at languages at all? Take some ideas from those.
100EYEo {}-a //is alternative for "for(int i=0; i<100; i++) {}"
-a for i<100 {}
might do it too. But I'd prefer 'for i=0,100 {}'.
if f() is a function call then
f();f();f();f();f();f();f();f();
resembles loop thus
f()^10 may be understand as a kinda "natural" form of loop
So a repeat-N-times loop. Try ntimes 10 {}
so
int i =0; {a[i++]==0? break} ^ strlen(a);
might be seen as kinda natural
(probably thought here strlen would be called many tiles so maybe
int LEN = strlen(a);
int i =0; {a[i++]==0? break} ^ LEN;
How you have a loop that iterates over 0 to LEN-1, and yet you still
have a repeat-N-times loop and need to manually initialise and step the index?
Try the idea from above (upper limit is exclusive):
-a for i=0,strlen(a) {a[i]==0 ? break}
(I won't comment on that ? construct.)
On 10/11/2026 02:11, bartc wrote:
Have you looked at /any/ other at languages at all? Take some ideas
from those.
Or look at C.-a It is not exactly a challenge to have :
#define For(_var, _limit) for (int _var = 0; _var < _limit; _var++)
and then you can write :
-a-a-a-aFor(i, 100)
With a little more effort, you can even make a single macro that could handle :
-a-a-a-aFor(100)-a-a-a // Automatic anonymous variable
and
-a-a-a-aFor(i, 1, 100)-a-a-a // If you don't want to start at 0
Try the idea from above (upper limit is exclusive):
-a-a for i=0,strlen(a) {a[i]==0 ? break}
(I won't comment on that ? construct.)
The big trouble with playing syntax games like Fir is doing (and you are doing, to a lesser extent) is that it is very easy to write code
snippets as examples, but very difficult to make a complete set of
syntax and grammar rules that are not ambiguous or in conflict with each other.-a Fir does not need to consider that at all in his ramblings - he just lets his cat wander across his keyboard.-a For a real language for widespread use,
it is far more difficult as you have to consider all
conceivable corner cases or strange usage.-a (For your languages, Bart,
you have a middle ground - since you are the only user, you can easily ensure that all users stay away from awkward corner cases.
Or look at C. It is not exactly a challenge to have :
#define For(_var, _limit) for (int _var = 0; _var < _limit; _var++)
and then you can write :
For(i, 100)
With a little more effort, you can even make a single macro that could
handle :
For(100) // Automatic anonymous variable
and
For(i, 1, 100) // If you don't want to start at 0
It is ludicrous to get annoyed about the "lack" of a feature in a
language when the language has all you need in order to provide that
feature. (It is fine to say you would /prefer/ if this feature were available out-of-the-box in C - that's just personal preference.)
On 10/11/2026 08:24, David Brown wrote:
On 10/11/2026 02:11, bartc wrote:
Have you looked at /any/ other at languages at all? Take some ideas
from those.
Or look at C.-a It is not exactly a challenge to have :
#define For(_var, _limit) for (int _var = 0; _var < _limit; _var++)
and then you can write :
-a-a-a-a-aFor(i, 100)
With a little more effort, you can even make a single macro that could
handle :
-a-a-a-a-aFor(100)-a-a-a // Automatic anonymous variable
and
-a-a-a-a-aFor(i, 1, 100)-a-a-a // If you don't want to start at 0
This is stuff I used to do. Then I realised then using a private macro library to refine the language doesn't work (when posting code on forums
for example).
They are vaguely C-like, but whatever fir is planning is a long way from
C anyway. He's not interested in workarounds using actual C.
it is far more difficult as you have to consider all conceivable
corner cases or strange usage.-a (For your languages, Bart, you have a
middle ground - since you are the only user, you can easily ensure
that all users stay away from awkward corner cases.
A language only needs to be real, not widespread, for the syntax choices
to be valid. There is nothing wrong or ambiguous about the grammar used
for my loop constructs.
This kind of feature is one of the simplest to get right in a language, especially when it is 1-based.
-a for i=1,100 {tab[i]=0}
David Brown <david.brown@hesbynett.no> writes:
[...]
Or look at C. It is not exactly a challenge to have :
#define For(_var, _limit) for (int _var = 0; _var < _limit; _var++)
and then you can write :
For(i, 100)
With a little more effort, you can even make a single macro that could
handle :
For(100) // Automatic anonymous variable
and
For(i, 1, 100) // If you don't want to start at 0
It is ludicrous to get annoyed about the "lack" of a feature in a
language when the language has all you need in order to provide that
feature. (It is fine to say you would /prefer/ if this feature were
available out-of-the-box in C - that's just personal preference.)
I don't entirely agree. Yes, you can create macros that make C
look like something else (I've done it myself). But any such
macro almost creates a new language that anyone reading the code
has to be familiar with.
If I see `For(100)`, I have to find out how it's defined *and*
understand the `for(...;...;...)` code that it expands to.8
If I thought C would benefit significantly from a Pascal-style for
loop (I don't), I'd want it added as a language feature, not hacked
by multiple incompatible macro definitions, one per project.
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
there are quite few subtle things here what given form gives what feelings
note in c that has no loop there is like no "natural" form of loop
(unles maybe just raw goto etc) at least i dont see it
this one wth power may be koncidered as somewhat natural
{-a } ^ t
(note my rider turned some ^100 to superscripts when i posted post in
text i meant ^ 100 not superscripts (unless the last ones (tab[i++] superscript 100)
i could made soem misteke coz when i consider
10 ^ t {}-a //read like 10 times "power" {} indexed by t
against
t ^ 10 {} //same
then the first one seems more appropriate
also
1..29 ^ t-a {}
a..b ^ i {}
imo this above is beter than
int i =a,b {}-a //<-- in this you take very rouhg (and) syntactic
decision imo (lk egeneralli a,b in c is considered like {a,b} so
it noramlly woud be {int i=a, b} tuple of things ..if no such thing as
i = {a, b} is not defined and if it looks liek it would like be defined
its definitely not like in for loop etc
the decisions behind
-aa..b ^ i {}
are imo quitte different and less colliding
(i know ^ is for xor etc, though i dont like tose bitwise operators as
thei are taken in c at allso, eventually some could substitute ^ with something other its secondary
-aa..b @ i {}
(i slightly prefer here a..b ^ i {} right now but the exact symbol
choices can be deferred)
//i also konsidered
a..b {tab[%1]=k}
//%1 being replcement for i - but i has good tradition in c
// but maybe it could be also present as an alternative solution
so right now from those considerations the ground im standing
as to loops would be that
1..29EYE!{tab[EYE!]=9}
1..29 ^ t-a {tab[t]=9}
1..29 {tab[%1]=9}
// maybe 1..29 ^ {tab[%1]=9}
//maybe ^ t =1..29-a {tab[%1]=9}
// alternatively {tab[%1]=9} ^ t= 1..76
//well in combination with power this assigment dont look bad here
maybe this also?
^ t=1..29 {tab[t]=9}
allows
^ t = {2,7,9,7,2,4,5} {f(t)}
//allows calls like f(2);f(7);f(9);f(7);f(2); f(4); f(5);
here this leftside form tooks weird more proper lik rightside
-a{ f(t)} ^ t = {2,7,9,7,2,4,5}
-a{ f(t)} ^ t = 2..50
overally not bad idea - power combined with those "value lists" either
a..b or {a,b,c}
//i put space among "^ t" artifically to editor not turn it in
superscript normally no space needed
maybe its even better than this unicode version
this may be also considered
T = {2,3,4,6} ;
-a foo(T);
normally it would just pass a tuple so maybe some operator for "pass sequentially in time" is maybe needed
T = {2,3,4,6} ;
-a foo(::T);
-a foo(^{2,3,4,6});
i dont know somethig could be taken
but if soe some could call few sets in parallel so tt fould need to be organized someway
-a foo(^{2,3,4,6}, ^{0,0,3,4});
-a foo(^{{2,0}{3,0}{4,3}{6,4}});
-aits also ok it semms you can pass it to whole block
{ }-a ^ t= {3,4,5}
as what it was started here
overally it gives both a loop syntax and new posibilities so its quite interesting path
fir pisze:
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-a-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
there are quite few subtle things here what given form gives what
feelings
note in c that has no loop there is like no "natural" form of loop
(unles maybe just raw goto etc) at least i dont see it
this one wth power may be koncidered as somewhat natural
{-a } ^ t
(note my rider turned some ^100 to superscripts when i posted post in
text i meant ^ 100 not superscripts (unless the last ones (tab[i++]
superscript 100)
i could made soem misteke coz when i consider
10 ^ t {}-a //read like 10 times "power" {} indexed by t
against
t ^ 10 {} //same
then the first one seems more appropriate
also
1..29 ^ t-a {}
a..b ^ i {}
imo this above is beter than
int i =a,b {}-a //<-- in this you take very rouhg (and) syntactic
decision imo (lk egeneralli a,b in c is considered like {a,b} so
it noramlly woud be {int i=a, b} tuple of things ..if no such thing as
i = {a, b} is not defined and if it looks liek it would like be
defined its definitely not like in for loop etc
the decisions behind
-a-aa..b ^ i {}
are imo quitte different and less colliding
(i know ^ is for xor etc, though i dont like tose bitwise operators as
thei are taken in c at allso, eventually some could substitute ^ with
something other its secondary
-a-aa..b @ i {}
(i slightly prefer here a..b ^ i {} right now but the exact symbol
choices can be deferred)
//i also konsidered
a..b {tab[%1]=k}
//%1 being replcement for i - but i has good tradition in c
// but maybe it could be also present as an alternative solution
so right now from those considerations the ground im standing
as to loops would be that
1..29EYE!{tab[EYE!]=9}
1..29 ^ t-a {tab[t]=9}
1..29 {tab[%1]=9}
// maybe 1..29 ^ {tab[%1]=9}
//maybe ^ t =1..29-a {tab[%1]=9}
// alternatively {tab[%1]=9} ^ t= 1..76
//well in combination with power this assigment dont look bad here
maybe this also?
^ t=1..29 {tab[t]=9}
allows
^ t = {2,7,9,7,2,4,5} {f(t)}
//allows calls like f(2);f(7);f(9);f(7);f(2); f(4); f(5);
here this leftside form tooks weird more proper lik rightside
-a-a{ f(t)} ^ t = {2,7,9,7,2,4,5}
-a-a{ f(t)} ^ t = 2..50
overally not bad idea - power combined with those "value lists" either
a..b or {a,b,c}
//i put space among "^ t" artifically to editor not turn it in
superscript normally no space needed
maybe its even better than this unicode version
this may be also considered
T = {2,3,4,6} ;
-a-a foo(T);
normally it would just pass a tuple so maybe some operator for "pass
sequentially in time" is maybe needed
T = {2,3,4,6} ;
-a-a foo(::T);
-a-a foo(^{2,3,4,6});
i dont know somethig could be taken
but if soe some could call few sets in parallel so tt fould need to be
organized someway
-a-a foo(^{2,3,4,6}, ^{0,0,3,4});
-a-a foo(^{{2,0}{3,0}{4,3}{6,4}});
-a-aits also ok it semms you can pass it to whole block
{ }-a ^ t= {3,4,5}
as what it was started here
overally it gives both a loop syntax and new posibilities so its quite
interesting path
ok so after those above considerations
-a(becouse i know not many can go thru them)
{} ^ t=2..99;-a //call {} 98 times
is good
and
{} ^ t ={2,3,1,2,3,88}; //call {} six times
it also probbaly need leftside form (normally power has no leftside form)
and it also need those form where you put this "powerings" inside
tab[^T] = ^S
where
int T = {2,8,9,100}; char* S = {"ahbahj","sds","Sdsd","sss"};
maybe - or somethig like that (as to those inner forms im not yet sure)
i must give kudos to bartc
this one
{} ^ t=2..99;
a bit resembles for int i = 2,30 though there are notable
differences - this for is wrong (becouse on abstract level this above is
not looping its more like powering so its 'abstract' looping
(and really that gives difference becouse if you-a go on some abstract
train of thjoughts the rails are different here)..also thi basic burden
and all that classical syntax dont fit its another vision
fir pisze:
fir pisze:
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-a-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
there are quite few subtle things here what given form gives what
feelings
note in c that has no loop there is like no "natural" form of loop
(unles maybe just raw goto etc) at least i dont see it
this one wth power may be koncidered as somewhat natural
{-a } ^ t
(note my rider turned some ^100 to superscripts when i posted post in
text i meant ^ 100 not superscripts (unless the last ones (tab[i++]
superscript 100)
i could made soem misteke coz when i consider
10 ^ t {}-a //read like 10 times "power" {} indexed by t
against
t ^ 10 {} //same
then the first one seems more appropriate
also
1..29 ^ t-a {}
a..b ^ i {}
imo this above is beter than
int i =a,b {}-a //<-- in this you take very rouhg (and) syntactic
decision imo (lk egeneralli a,b in c is considered like {a,b} so
it noramlly woud be {int i=a, b} tuple of things ..if no such thing as
i = {a, b} is not defined and if it looks liek it would like be
defined its definitely not like in for loop etc
the decisions behind
-a-aa..b ^ i {}
are imo quitte different and less colliding
(i know ^ is for xor etc, though i dont like tose bitwise operators
as thei are taken in c at allso, eventually some could substitute ^
with something other its secondary
-a-aa..b @ i {}
(i slightly prefer here a..b ^ i {} right now but the exact symbol
choices can be deferred)
//i also konsidered
a..b {tab[%1]=k}
//%1 being replcement for i - but i has good tradition in c
// but maybe it could be also present as an alternative solution
so right now from those considerations the ground im standing
as to loops would be that
1..29EYE!{tab[EYE!]=9}
1..29 ^ t-a {tab[t]=9}
1..29 {tab[%1]=9}
// maybe 1..29 ^ {tab[%1]=9}
//maybe ^ t =1..29-a {tab[%1]=9}
// alternatively {tab[%1]=9} ^ t= 1..76
//well in combination with power this assigment dont look bad here
maybe this also?
^ t=1..29 {tab[t]=9}
allows
^ t = {2,7,9,7,2,4,5} {f(t)}
//allows calls like f(2);f(7);f(9);f(7);f(2); f(4); f(5);
here this leftside form tooks weird more proper lik rightside
-a-a{ f(t)} ^ t = {2,7,9,7,2,4,5}
-a-a{ f(t)} ^ t = 2..50
overally not bad idea - power combined with those "value lists"
either a..b or {a,b,c}
//i put space among "^ t" artifically to editor not turn it in
superscript normally no space needed
maybe its even better than this unicode version
this may be also considered
T = {2,3,4,6} ;
-a-a foo(T);
normally it would just pass a tuple so maybe some operator for "pass
sequentially in time" is maybe needed
T = {2,3,4,6} ;
-a-a foo(::T);
-a-a foo(^{2,3,4,6});
i dont know somethig could be taken
but if soe some could call few sets in parallel so tt fould need to
be organized someway
-a-a foo(^{2,3,4,6}, ^{0,0,3,4});
-a-a foo(^{{2,0}{3,0}{4,3}{6,4}});
-a-aits also ok it semms you can pass it to whole block
{ }-a ^ t= {3,4,5}
as what it was started here
overally it gives both a loop syntax and new posibilities so its
quite interesting path
ok so after those above considerations
-a-a(becouse i know not many can go thru them)
{} ^ t=2..99;-a //call {} 98 times
is good
and
{} ^ t ={2,3,1,2,3,88}; //call {} six times
it also probbaly need leftside form (normally power has no leftside form)
and it also need those form where you put this "powerings" inside
tab[^T] = ^S
where
int T = {2,8,9,100}; char* S = {"ahbahj","sds","Sdsd","sss"};
maybe - or somethig like that (as to those inner forms im not yet sure)
i must give kudos to bartc
this one
{} ^ t=2..99;
a bit resembles for int i = 2,30 though there are notable
differences - this for is wrong (becouse on abstract level this above
is not looping its more like powering so its 'abstract' looping
(and really that gives difference becouse if you-a go on some abstract
train of thjoughts the rails are different here)..also thi basic
burden and all that classical syntax dont fit its another vision
though for exampla this sign ^ imo could and mabe should be reead "for"
^T foo(T*3);
depending what T is
like int T = 1..29; //T is scope/range
int T = {2,3,4,55,5,3,4}; //t is list/vector/structure
foo(^T*3); probably can be used as a shortcut and
funnt "^" is read as for
so this is "short for" discovery i could say
On 10/11/2026 13:08, bartc wrote:
A language only needs to be real, not widespread, for the syntax
choices to be valid. There is nothing wrong or ambiguous about the
grammar used for my loop constructs.
This kind of feature is one of the simplest to get right in a
language, especially when it is 1-based.
The very fact that you think this is something to "get right" shows
where you go wrong in language design, language comparison, and language discussions.
What's natural about ^ meaning iteration? In C it means bitwise
exclusive or. In other languages it might mean pow() or pointer deref.
(Remember your example above was f();f();f() not f()*f()*f().)
int LEN = strlen(a);
int i =0; {a[i++]==0? break} ^ LEN;
How you have a loop that iterates over 0 to LEN-1, and yet you still
have a repeat-N-times loop and need to manually initialise and step the index?
bartc pisze:
int LEN = strlen(a);
int i =0; {a[i++]==0? break} ^ LEN;
How you have a loop that iterates over 0 to LEN-1, and yet you still
have a repeat-N-times loop and need to manually initialise and step
the index?
i dont have to, i acn...and this pieco of code above is especially
neat(its in fact the answer)
fir pisze:
bartc pisze:
int LEN = strlen(a);
int i =0; {a[i++]==0? break} ^ LEN;
How you have a loop that iterates over 0 to LEN-1, and yet you still
have a repeat-N-times loop and need to manually initialise and step
the index?
i dont have to, i acn...and this pieco of code above is especially
neat(its in fact the answer)
its in fact this so called "manual" c - and maybe this makes it so
good - everybody loves manual c
note this syntax you proposed
for int i = 1,80 {}
is already not manual
even for(int =0; i<80; i++) isl ike less "manual" tha this
-aint LEN = strlen(a);
-aint i =0; {a[i++]==0? break} ^ LEN;
imo its more manual becouse it has not this "what loop iteration is" topic
powering here (as reapating {}{}{}{}) is much more manual
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
there are quite few subtle things here what given form gives what feelings
note in c that has no loop there is like no "natural" form of loop
(unles maybe just raw goto etc) at least i dont see it
this one wth power may be koncidered as somewhat natural
{-a } ^ t
-aa..b @ i {}Have you considered what the construct 'x .. y', if it was part of the
(i slightly prefer here a..b ^ i {} right now but the exact symbol
choices can be deferred)
//i also konsidered
a..b {tab[%1]=k}
//%1 being replcement for i - but i has good tradition in c
// but maybe it could be also present as an alternative solution
so right now from those considerations the ground im standing
as to loops would be that
1..29EYE!{tab[EYE!]=9}
1..29 ^ t-a {tab[t]=9}
1..29 {tab[%1]=9}
// maybe 1..29 ^ {tab[%1]=9}
//maybe ^ t =1..29-a {tab[%1]=9}
// alternatively {tab[%1]=9} ^ t= 1..76
//well in combination with power this assigment dont look bad here
maybe this also?
^ t=1..29 {tab[t]=9}
allows
^ t = {2,7,9,7,2,4,5} {f(t)}
//allows calls like f(2);f(7);f(9);f(7);f(2); f(4); f(5);
On 10/11/2026 12:51, fir wrote:
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-a-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
I'd considered using 1..100 and 1 to 100 but your aim seemed to be conciseness. "1,100" is used in Lua.
the @i is also missing so you basically have:
-a x {}
Wasn't this the syntax for your composite struct/function definition?
On 10/11/2026 12:51, fir wrote:
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-a-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
I'd considered using 1..100 and 1 to 100 but your aim seemed to be conciseness. "1,100" is used in Lua.
there are quite few subtle things here what given form gives what
feelings
note in c that has no loop there is like no "natural" form of loop
(unles maybe just raw goto etc) at least i dont see it
this one wth power may be koncidered as somewhat natural
{-a } ^ t
I once used this:
-a (n || s)
for repeat-N-times. I decided that was too quaint.
(If a loop were to return a value, as happens in some languages, then
such a compact form can be desirable to use within expressions.)
-a-aa..b @ i {}Have you considered what the construct 'x .. y', if it was part of the syntax, could have lots of different uses. For example:
(i slightly prefer here a..b ^ i {} right now but the exact symbol
choices can be deferred)
-a-a if x in a..b-a-a-a-a-a-a # test a within a range
-a-a A[i..j]-a-a-a-a-a-a-a-a-a-a-a # slicing
So it would not be obvious that a..b introduces a loop. I assume that
'a..b @ i {}' means this in my own syntax:
-a for i in a..b do end
Which one do you think is clearer? Further, it is possible to do
-a for i in x do end
where 'x' might be a range defined elsewhere, or some collection. Now
that '..' cue is missing since you'd have to write 'x @ i {}'. But in
your next example ...
//i also konsidered
a..b {tab[%1]=k}
the @i is also missing so you basically have:
-a x {}
Wasn't this the syntax for your composite struct/function definition?
//%1 being replcement for i - but i has good tradition in c
// but maybe it could be also present as an alternative solution
so right now from those considerations the ground im standing
as to loops would be that
1..29EYE!{tab[EYE!]=9}
1..29 ^ t-a {tab[t]=9}
1..29 {tab[%1]=9}
// maybe 1..29 ^ {tab[%1]=9}
//maybe ^ t =1..29-a {tab[%1]=9}
// alternatively {tab[%1]=9} ^ t= 1..76
In practice you don't have many fixed ranges like this; the upper limit
is usually tied to the bounds of 'tab', so how would that look? Maybe:
-a-a for &x in tab {x = 9}
where the '&x' means that x is a writeable reference to the element.
(C++ might have this.)
//well in combination with power this assigment dont look bad here
maybe this also?
^ t=1..29 {tab[t]=9}
allows
^ t = {2,7,9,7,2,4,5} {f(t)}
//allows calls like f(2);f(7);f(9);f(7);f(2); f(4); f(5);
This is still just a form of:
-a-a for x in tab {}
For example:
-a-a for x in (2,7,9,7,2,4,5) {f(x)}
But this is more high-level. Just look at some other languages; it's all been done!
bartc pisze:
On 10/11/2026 12:51, fir wrote:
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-a-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
I'd considered using 1..100 and 1 to 100 but your aim seemed to be
conciseness. "1,100" is used in Lua.
there are quite few subtle things here what given form gives what
feelings
note in c that has no loop there is like no "natural" form of loop
(unles maybe just raw goto etc) at least i dont see it
this one wth power may be koncidered as somewhat natural
{-a } ^ t
I once used this:
-a-a (n || s)
for repeat-N-times. I decided that was too quaint.
(If a loop were to return a value, as happens in some languages, then
such a compact form can be desirable to use within expressions.)
-a-aa..b @ i {}Have you considered what the construct 'x .. y', if it was part of the
(i slightly prefer here a..b ^ i {} right now but the exact symbol
choices can be deferred)
syntax, could have lots of different uses. For example:
-a-a-a if x in a..b-a-a-a-a-a-a # test a within a range
-a-a-a A[i..j]-a-a-a-a-a-a-a-a-a-a-a # slicing
So it would not be obvious that a..b introduces a loop. I assume that
'a..b @ i {}' means this in my own syntax:
-a-a for i in a..b do end
Which one do you think is clearer? Further, it is possible to do
-a-a for i in x do end
where 'x' might be a range defined elsewhere, or some collection. Now
that '..' cue is missing since you'd have to write 'x @ i {}'. But in
your next example ...
//i also konsidered
a..b {tab[%1]=k}
the @i is also missing so you basically have:
-a-a x {}
Wasn't this the syntax for your composite struct/function definition?
//%1 being replcement for i - but i has good tradition in c
// but maybe it could be also present as an alternative solution
so right now from those considerations the ground im standing
as to loops would be that
1..29EYE!{tab[EYE!]=9}
1..29 ^ t-a {tab[t]=9}
1..29 {tab[%1]=9}
// maybe 1..29 ^ {tab[%1]=9}
//maybe ^ t =1..29-a {tab[%1]=9}
// alternatively {tab[%1]=9} ^ t= 1..76
In practice you don't have many fixed ranges like this; the upper
limit is usually tied to the bounds of 'tab', so how would that look?
Maybe:
-a-a-a for &x in tab {x = 9}
where the '&x' means that x is a writeable reference to the element.
(C++ might have this.)
//well in combination with power this assigment dont look bad here
maybe this also?
^ t=1..29 {tab[t]=9}
allows
^ t = {2,7,9,7,2,4,5} {f(t)}
//allows calls like f(2);f(7);f(9);f(7);f(2); f(4); f(5);
This is still just a form of:
-a-a-a for x in tab {}
For example:
-a-a-a for x in (2,7,9,7,2,4,5) {f(x)}
But this is more high-level. Just look at some other languages; it's
all been done!
its obviously not becouse you dont put those for in loops in places
tab[^{1,3,7,9}] = 'corner';
did they do
tab[for x in {1,3,7,9}] = 'corner';
thet would looks weird..there are abstract differencies in some cyntax
idea which are not the same as shallow syntax comparisons
in fact it shows shortcut may be eventually used also
tab[1,3,7,9] = 'corner';
but thats static case
t[] = {1,7,9,3}
tab[t] = 'corner'
could also be used
so in fact indeed some ^ seem not mandatory
fir pisze:
bartc pisze:note becouse this is important to realize:
On 10/11/2026 12:51, fir wrote:
bartc pisze:
-a-a for i=1,100 {tab[i]=0}
this on i dont like better woud be imo
-a-afor i = 1 to 100 {tab[i]=0}
but still it feels too much basic
I'd considered using 1..100 and 1 to 100 but your aim seemed to be
conciseness. "1,100" is used in Lua.
there are quite few subtle things here what given form gives what
feelings
note in c that has no loop there is like no "natural" form of loop
(unles maybe just raw goto etc) at least i dont see it
this one wth power may be koncidered as somewhat natural
{-a } ^ t
I once used this:
-a-a (n || s)
for repeat-N-times. I decided that was too quaint.
(If a loop were to return a value, as happens in some languages, then
such a compact form can be desirable to use within expressions.)
-a-aa..b @ i {}Have you considered what the construct 'x .. y', if it was part of
(i slightly prefer here a..b ^ i {} right now but the exact symbol
choices can be deferred)
the syntax, could have lots of different uses. For example:
-a-a-a if x in a..b-a-a-a-a-a-a # test a within a range
-a-a-a A[i..j]-a-a-a-a-a-a-a-a-a-a-a # slicing
So it would not be obvious that a..b introduces a loop. I assume that
'a..b @ i {}' means this in my own syntax:
-a-a for i in a..b do end
Which one do you think is clearer? Further, it is possible to do
-a-a for i in x do end
where 'x' might be a range defined elsewhere, or some collection. Now
that '..' cue is missing since you'd have to write 'x @ i {}'. But in
your next example ...
//i also konsidered
a..b {tab[%1]=k}
the @i is also missing so you basically have:
-a-a x {}
Wasn't this the syntax for your composite struct/function definition?
//%1 being replcement for i - but i has good tradition in c
// but maybe it could be also present as an alternative solution
so right now from those considerations the ground im standing
as to loops would be that
1..29EYE!{tab[EYE!]=9}
1..29 ^ t-a {tab[t]=9}
1..29 {tab[%1]=9}
// maybe 1..29 ^ {tab[%1]=9}
//maybe ^ t =1..29-a {tab[%1]=9}
// alternatively {tab[%1]=9} ^ t= 1..76
In practice you don't have many fixed ranges like this; the upper
limit is usually tied to the bounds of 'tab', so how would that look?
Maybe:
-a-a-a for &x in tab {x = 9}
where the '&x' means that x is a writeable reference to the element.
(C++ might have this.)
//well in combination with power this assigment dont look bad here
maybe this also?
^ t=1..29 {tab[t]=9}
allows
^ t = {2,7,9,7,2,4,5} {f(t)}
//allows calls like f(2);f(7);f(9);f(7);f(2); f(4); f(5);
This is still just a form of:
-a-a-a for x in tab {}
For example:
-a-a-a for x in (2,7,9,7,2,4,5) {f(x)}
But this is more high-level. Just look at some other languages; it's
all been done!
its obviously not becouse you dont put those for in loops in places
tab[^{1,3,7,9}] = 'corner';
did they do
tab[for x in {1,3,7,9}] = 'corner';
thet would looks weird..there are abstract differencies in some cyntax
idea which are not the same as shallow syntax comparisons
in fact it shows shortcut may be eventually used also
tab[1,3,7,9] = 'corner';
but thats static case
t[] = {1,7,9,3}
tab[t] = 'corner'
could also be used
so in fact indeed some ^ seem not mandatory
is some has some deeper "behind a syntax" observations
then aspects of those abservations may open som enew pathes in code
thinking tha just shallowly comparing syntaxes (and not realizing the "behind" side dfferences which are kinda invisible (untill youre very
good in all that, bein able to catch and compare this invisible "behind" side ideas)
you may say X looks like other X (ehere X is piece of some syntax) - it looks very close or it even may just look the same
if thhere are other ideas on "behind" sides of one X and other X
they are not he same - especially if one X with its behind ideas opens
some new syntax gates/corridors/pathes for things
right now after those combinations/considerations it seems:
to get a loop in c you must
"multiply or power" given block of code with "range or list"
(as i said its rather power but is kinda abstract power so i some way
one could also say its abstract operation of multiply, and in common language if some has
"block" X "range"
"block" X "list"
some can say imo multiply some can say "power to" depending what is more convenient (i the context of those sentence multiply fits, normally imo power more fits, but both somewhat fits)
so
tab[2..88] this is a loop (as tab is multipied by range or powered by
range)
tab[t] -if t is array - is also a loop (of size of length of t)
tab[2,36,7,3,2,4,5] - is aloso a loop (t turns)
tab[i] would be loop if i is scope/range, if i is sole value its not a loop
so ine can evenylually say that if i is value say 100 some can use ^ to
turn it into scope/range
int i = 0..100;
tab[i]=0; //loop (101 turns)
int i=100;
tab[i] = 0;// not loop
tab[^i] ; //loop (100 turns)
all that abstract powering ideas lead to that
yet to sey its cklearrer (as i know my "chain of reasoning" may be hard
to folow)..some pieces i can explain with no context so its easy to gat
say
int a[] = {2,4,5,6,5,33,223,445,5};
it is "spatial" array (i mean sequence of ints in ram?
or it is "temporal cascade"
it MAY be both so it probbaly has not much sence to denote this
spatial int a[] = {2,4,5,6,5,33,223,445,5};
temporal int a[] = {2,4,5,6,5,33,223,445,5};
becouse compilar anyway cant probably hold this temporal list other way
than in ram (sometimes it may eventually discard it but im not sure if noting it as a temporal is veru sefull)
so
int a[] = {2,4,5,6,5,33,223,445,5};
is both "spacial ram array" and "temporal cascde"
the using it as spacial array would just pass a pointer to it
like passing to foo(a) where foo waits for int*
passing it to tab[a] = something just calls a temporal cascade
of calls (which is loop)
the question is where with context you may know its spatial and when you
know when its temporat and if some contextes it can be both make some
syntax to point put shich one it may be
scopes/ranges ike 5..10 also may be used for temporal cascases
(though they also may be used for spacial arrays)
IN fact it shows (this chain of reasoning shows) in C you may realize
for loops just by throwing temporal cascades in code (various ways)
-a {^tab=^tabb?:break} //break on 0
fir pisze:
-a-a {^tab=^tabb?:break} //break on 0
there is hovever a question
t[0..20]=s[0..10];
what now? t wants to be unwind 21 times where s wants to be
-aunwind only 11
in such case seem natural to unwind 11 and break whole loop
and here would be good so
^s=^t
or t=s or t[]=s[] work right away but im not sure if its general case
{if(!t[]=s[]) break; } //that would be copy until 0-termination
also good notice ranges may be named more meaningful names than sole elements
which is good
int row = 0..799;
int rows= 0..599;
tab[rows][row] = 0;
hovever in this case its wrong becouse columns and row are or
"parrallel" sync cascades by those different rank ones
so something must be added i not yet know what exactly
tab[^rows][row] = 0;
added ^ here but here its not exactly that becouse before like
^100 was a sign for promotion value to range, now row and rows are
ranges so something other is needed just to denote "unsynctd" second temporal cascade (but as i dont know what it should be and im tired i
not put it yet)
if some not worries of adding more syntax than probably needed could go with
fir pisze:
fir pisze:
-a-a {^tab=^tabb?:break} //break on 0
there is hovever a question
t[0..20]=s[0..10];
what now? t wants to be unwind 21 times where s wants to be
-a-aunwind only 11
in such case seem natural to unwind 11 and break whole loop
and here would be good so
^s=^t
or t=s or t[]=s[] work right away but im not sure if its general case
{if(!t[]=s[]) break; } //that would be copy until 0-termination
also good notice ranges may be named more meaningful names than sole
elements
which is good
int row = 0..799;
int rows= 0..599;
tab[rows][row] = 0;
hovever in this case its wrong becouse columns and row are or
"parrallel" sync cascades by those different rank ones
so something must be added i not yet know what exactly
tab[^rows][row] = 0;
added ^ here but here its not exactly that becouse before like
^100 was a sign for promotion value to range, now row and rows are
ranges so something other is needed just to denote "unsynctd" second
temporal cascade (but as i dont know what it should be and im tired i
not put it yet)
if some not worries of adding more syntax than probably needed could
go with
-aint row = 0..799;
-aint rows= 0..599;
-atab[^^rows][^row] = 0;
where ^row is to read "for row" and ^^rows is to read "second rank for
for rows" then its at least very clear (almost like seing this
traditional for headers)
how to fire or leash thoce temoral cascades need a bit of practice
If I thought C would benefit significantly from a Pascal-style for
loop (I don't), I'd want it added as a language feature, [...]
Anyway, how does C get away with having 'while' both starting a
loop statement, and ending one?!)
bartc <bc@freeuk.com> writes:
Anyway, how does C get away with having 'while' both starting a
loop statement, and ending one?!)
What is it that you think C is getting away with by having both
while() and do/while() loop forms?
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 56:58:54 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
4 files (9,632K bytes) |
| Messages: | 285,828 |