• p = {1,0,0}

    From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 1 14:32:34 2026
    From Newsgroup: comp.lang.c

    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Sun Nov 1 13:41:59 2026
    From Newsgroup: comp.lang.c

    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) {
    T s;
    s = (T){10,20};
    }


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 1 15:10:04 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    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};
    }
    this (T) is rather silly here - i mean its ok if you cast something but
    if no its like

    int a = (int) 20;


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 1 16:13:18 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    bartc pisze:
    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};
    }
    this (T) is rather silly here - i mean its ok if you cast something 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




    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Mon Nov 2 16:46:13 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    fir pisze:
    bartc pisze:
    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};
    }
    this (T) is rather silly here - i mean its ok if you cast something
    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


    lack of it i would even add to the list of top c annoyances - becouse
    indeed ts annoying..it also unlocks quite sane way of doing things in c
    as i said..it simply should be addad to c..but this c comitee is not
    much good in its decisions imo
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From David Brown@david.brown@hesbynett.no to comp.lang.c on Mon Nov 2 17:36:06 2026
    From Newsgroup: comp.lang.c

    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 T s;
    -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. 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 as
    type std::initializer_list<int> (the "int" part is automatically
    inferred). Making this work involves quite a bit of additional C++
    machinery that does not exist in C.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Mon Nov 2 18:47:24 2026
    From Newsgroup: comp.lang.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:

    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:

    T s = {10, 20};

    What determines the type of {10, 20} in this case?


    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.
    In the language or compiler? Because machinery can be added to C too.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Mon Nov 2 20:54:13 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    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 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.
    In the language or compiler? Because machinery can be added to C too.


    you once asked if i want some of what i talk someone should implement 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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Mon Nov 2 20:56:03 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    bartc pisze:
    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.

    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 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.
    In the language or compiler? Because machinery can be added to C too.


    you once asked if i want some of what i talk someone should implement
    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

    im not even specially interested in what not breaks this compatibility
    with old sources but even thse major changes (like definitions being
    seen down in code) they could also add


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From David Brown@david.brown@hesbynett.no to comp.lang.c on Mon Nov 2 21:29:16 2026
    From Newsgroup: comp.lang.c

    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 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". As an integer constant expression with value 0,
    it can be /converted/ to any pointer type, giving a null pointer
    constant. It can also be converted to a float, or other arithmetic
    type. But as it stands, "0" has a fixed type - "int".


    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?


    That is initialisation, which is a different matter. 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. I'd be happy if "s = { 10, 20 };" worked in C. It doesn't work in C, however - this is one of many reasons why I usually
    work in C++ rather than C.)


    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.
    In the language or compiler? Because machinery can be added to C too.


    std::initializer_list is a template. 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. It's not something I have thought through in detail.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Janis Papanagnou@janis_papanagnou+ng@hotmail.com to comp.lang.c on Mon Nov 2 21:39:36 2026
    From Newsgroup: comp.lang.c

    On 2026-11-02 21:29, David Brown wrote:

    [...] - just use C++.

    +1

    ("Symbolic pun" intended; sorry, could not resist.)

    Janis

    [...]

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Keith Thompson@Keith.S.Thompson+u@gmail.com to comp.lang.c on Mon Nov 2 14:52:37 2026
    From Newsgroup: comp.lang.c

    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).
    --
    Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
    void Void(void) { Void(); } /* The recursive call of the void */
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Mon Nov 2 22:58:03 2026
    From Newsgroup: comp.lang.c

    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 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.
    In the language or compiler? Because machinery can be added to C too.


    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.)


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From David Brown@david.brown@hesbynett.no to comp.lang.c on Tue Nov 3 11:09:21 2026
    From Newsgroup: comp.lang.c

    On 02/11/2026 23:58, bartc wrote:
    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.)

    In C, it is not a "tuple of two ints". C has no concept of "tuple".
    This is simply the syntax used for multiple initialisers. That is where
    the limitation lies - there is no way in C to have a kind of on-the-fly structure or array type. (Some languages have it, C does not.) When
    you write "(T) { 10, 20 }", you are /not/ writing a cast or any other
    kind of type conversion. You are using the particular syntax for a
    "compound literal". The syntax is obviously picked to be similar to a
    cast, and similar to an initialisation, but it is /not/ a cast. It is creating a temporary object of type T that is initialised with the
    values 10 and 20.


    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.)

    The types relevant to initialisation come from the initialised type.
    When you write "T s = { 10, 20 };", you do not have an object with value
    "{ 10, 20 }" of some automatic type that is then assigned to "s". What
    you have is a short-cut syntax for :

    T s;
    s.x = 10;
    s.y = 20;

    "{ 10, 20 }" does not exist on its own, it does not have a type, it is
    not a "tuple", there are no casts or conversions, and it is not assigned
    to "s" or anything else.



    (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.

    That paragraph would make sense if I were the benevolent dictator for
    life for the C programming language. I am not.

    C++ has many features that C does not. It also has many complications.
    These are tradeoffs, and for much of the work I do, C++ is usually a
    better choice for me. (For other things I do, Python is usually a
    better choice than either C or C++. And for some things, C is a better choice.) It is undoubtedly the case that C++ has seen many more
    dramatic changes than C. It is also undoubtedly the case that much of
    the complication of C++ as a language is because of features being
    retrofitted into a language that did not support them originally.



    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.
    In the language or compiler? Because machinery can be added to C too.


    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.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 13:19:02 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    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 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.
    In the language or compiler? Because machinery can be added to C too.


    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.)



    [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]


    what this {2,7} is is generally quite clear its a value of 'snonymous structure' of 2 ints

    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

    this btw shows that strict c rules most probably shows that

    {{1,2},{2,3}} is a structure of structures and if some need to hools
    a pointer th should probably use this & sign

    {&{1,2},&{2,3}} //structure of two pointers to 2 structures that are initialised and lays somewgere in a ram so there are 3 blocks of data
    that may be separate in ram

    not saying this & here is good , but imo present rules of c would
    lead to that


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 13:29:59 2026
    From Newsgroup: comp.lang.c

    Keith Thompson pisze:
    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).

    thse people DB and KT are like c beaurocrates where I and BC look on ths
    ame things as like a theoretical c view

    so its theoretical c and beaurocratic c meet up
    (ofc being a c beaurocrate is not bad, its even quite good imo...
    but doin c thery is also very good imo..

    so in that context {10,20} is a thing in theoretical c and its not only
    this what is in beaurocratic c

    NOTE what is true, c is not only what is in beurocratic areas its also
    quite theoretical concept/being

    (this way i dont like people talking what is not a beaurocratic c is not
    a c - it often is deeper theoretial c, though there is also some border
    inside but not all concept could be named deeper c/theoretical c i
    guess, but some can)

    (which can and which cant is an other story)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 14:29:59 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    (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.)

    i facy the usage in functions is probably the main (or main aside other
    mains) usage of it

    like

    foo({x,y,z}) //for foo(float3 x)

    instead of
    float3 x = {23,4,4};
    foo(x);

    very handy same for

    foo(&{3,4,d}) //for foo(float3* x)

    maybe even handier

    probabbly also to allow skipping return values in expressions


    zoo({x,y,} foo({2,3,4}))

    foo terurns int-int-int but zoo takes only 2 ints

    also incidentally seems it allows to return values rightside


    zoo( foo({2,3,4}) {x,y,} )

    which is very worth rethinking

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 14:42:04 2026
    From Newsgroup: comp.lang.c

    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

    foo(){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


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Tue Nov 3 14:07:32 2026
    From Newsgroup: comp.lang.c

    On 03/11/2026 12:19, fir wrote:
    bartc pisze:

    On 01/11/2026 13:32, fir wrote:

    the fact stat some cannot assign a structure like
    this

    s = {x,y};
    (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.)



    [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:

    p := (100, 200, 300)
    q := (20, 30, 40)
    m := (p + q) / 2

    println m # (60.00, 115.00, 170.00)

    It was a 3D graphics application.

    In my systems language, it worked like this, and from the 1980s:

    record point =
    int x, y
    end

    point p = (100, 200) # 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:

    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?


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 15:45:10 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    On 03/11/2026 12:19, fir wrote:
    bartc pisze:

    On 01/11/2026 13:32, fir wrote:

    the fact stat some cannot assign a structure like
    this

    s = {x,y};
    (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.)



    [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


    wel this is not related..this is not by visual resemblances im talkin
    about - but there are some quite deeper observations that i originated
    and i know people are generally not honest but for some king of
    historical truth this shpould be kept


    in this case its somewhat "little" remarks here and its also not about
    being stolen coz its free its more like not keeping honesty if things
    come form my observations not from other source

    what you say here is not related its not a concept of c and what i was
    sain about is strictly in c context (and has may qualities of this
    context just with some extension)

    if you would talk here on tuples in python or c++ is totally different thing



    -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?



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 15:54:24 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    On 03/11/2026 12:19, fir wrote:
    bartc pisze:

    On 01/11/2026 13:32, fir wrote:

    the fact stat some cannot assign a structure like
    this

    s = {x,y};
    (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.)



    [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?

    so if youre talkin about tuples in python its not that think im talkin
    about..
    i overally was speaking more general here

    here for example idea to use a = {2,3} (like it is in normal c )
    its quite a public domain and i wouldnt say i want to be credited as an
    owner of this idea, but such things generally should be credited if
    they are follows to some observations.. so im not talking about "owning"
    but much more slight thing of bein credited in some more like "paper"
    way of mentioning something

    ho do you acces the elements? you dont you assign it to some variable
    then acces the variable..

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 16:09:02 2026
    From Newsgroup: comp.lang.c

    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

    -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 {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



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 16:18:53 2026
    From Newsgroup: comp.lang.c

    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]
    {
    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




    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 16:38:00 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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
    }


    some question arise

    becouse there are option to treat function as a structure with value
    or using this syntax to adres outcoming value

    (int a) + (int b) {int x = a+b }

    (int a) foo (int b) { int x = (a+b)/2, int y = (a-b)/2 }

    here basic seem this structural

    output one also can be defined like here

    rand (int d) [int x] { x = rand()%d}

    rand 10 x

    there is also question if they should be tied/blend together some way

    i dont know at the moment - though question is kinda interesting









    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





    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 16:48:42 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    On 03/11/2026 12:19, fir wrote:
    bartc pisze:

    On 01/11/2026 13:32, fir wrote:

    the fact stat some cannot assign a structure like
    this

    s = {x,y};
    (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.)



    [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

    its like those people form spider-man (like sand man etc) or x-man

    so would be foam-man here

    (though i suggest not to foam, adding it just becouse its x-man and
    humour values)

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 16:55:32 2026
    From Newsgroup: comp.lang.c

    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





    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 17:06:26 2026
    From Newsgroup: comp.lang.c

    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()}


    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






    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Tue Nov 3 16:26:36 2026
    From Newsgroup: comp.lang.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...?




    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
    You're trying to create a language syntax like monkeys typing at 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.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 17:34:02 2026
    From Newsgroup: comp.lang.c

    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(); 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










    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
    You're trying to create a language syntax like monkeys typing at 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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 17:47:12 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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










    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
    You're trying to create a language syntax like monkeys typing at
    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

    instead of foaming...


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 17:54:02 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    fir pisze:
    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










    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
    You're trying to create a language syntax like monkeys typing at
    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

    instead of foaming...


    note btw you often mention this your language or maybe even pack of
    languages and i personally dont see a problem there...somethimes i read
    it sometimes not..you show your design choices its ok

    i think hovever you should name them and use those names - yet better
    give it to download and use..becouse if yu not use names and you get
    some its too easy to mees it all up

    imegine some would not name pythoon or java only said "in my language"
    it would be a mess

    (in my case its diffetrent becous eits not on language i mostly talk
    about c solutions (separate language solutio on ground of hard c) than
    in more theretical but all this solutions should be in a way considered separatelly)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 3 22:08:37 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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


    overally i remember i was not quite sure how to define operators in c
    but its probably like this:

    some(int a) //some module
    {
    x++, y +=a, z=a //some code
    int x y z // fields
    foo (int x) {} //function definition
    !(int x) {printf("%d", x)} //operator definition
    (int x) %% (int y) {} //operator definition

    }

    //usage

    some(4) //calls code
    some //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













    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
    You're trying to create a language syntax like monkeys typing at
    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


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Wed Nov 4 14:14:53 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    fir pisze:
    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


    overally i remember i was not quite sure how to define operators in c
    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

    }


    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













    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
    You're trying to create a language syntax like monkeys typing at
    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



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Wed Nov 4 14:27:41 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    fir pisze:
    fir pisze:
    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


    overally i remember i was not quite sure how to define operators in c
    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)



    note if i would like to 'officially' publish it imo its better to finish
    it (at least some layer of it) and then get some time ('vacatio legis'
    some could say) to toy with that being somewhat convinced it has no
    changes or additions needed..so its good to have this time
    (and its probably seem like i need yet few years maybe)


    overally what started as a series of some extensions that "would be good
    to have in c" (those more like havin returned 2 or mole values, acces to static fields of functions, maiing variables stack explicite and so on)
    it shoved evolved into this fractal 'hipermodularity'


    it was somewhat unexpected i could say but it oryginated as this
    observation that this fractal hipermodularity is like consequence in c
    so its ok

    it makes those 'solutions' be packed like some new 'paradigm' or what to
    call it so it makes it like more 'closed' here, and its also ok
    (becouse if it is somewhat 'closed' i may say at least at some layer its 'finished' othervise if having a set of loose additions i would have no
    so much rigid occastion to say so

    (old fir)

    //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













    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
    You're trying to create a language syntax like monkeys typing at
    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




    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Thu Nov 5 19:10:54 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    fir pisze:
    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


    overally i remember i was not quite sure how to define operators in c
    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



    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 {
    __asm_i32 value;

    (int a)=(int b)
    {
    _asm mov a b
    }


    (int a)+(int b)
    {
    int c;
    _asm mov register a
    _asm_add register b
    _asm mov c register

    }

    (int a)-(int b)
    {
    int c;
    _asm mov register a
    _asm_sub register b
    _asm mov c register
    }

    (int a)*(int b)
    {
    int c;
    _asm mov register a
    _asm_mul register b
    _asm mov c register
    }

    (int a)/(int b)
    {
    int c;
    _asm mov register a
    _asm_div register b
    _asm mov c register
    }

    }


    then

    int x = a*b+c/d-e

    would just yeild to sequential calls

    =(k,(-(/(+(*(a,b),c),d),e)))

    should it work?

    to weary to check














    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
    You're trying to create a language syntax like monkeys typing at
    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



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Thu Nov 5 19:38:36 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    fir pisze:
    fir pisze:
    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


    overally i remember i was not quite sure how to define operators in c
    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 }


    soory here should be

    (int a)=(int b)
    {
    _asm mov register b
    _asm mov a register
    }



    -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


    function calls do some 'aliasing' (name substitution so generated code
    would be

    *:
    _asm mov register a
    _asm_mul register b
    _asm mov local register
    +:
    _asm mov register local
    _asm_add register c
    _asm mov local register
    /:

    _asm mov register local
    _asm_div register d
    _asm mov local register
    -:
    _asm mov register local
    _asm_sub register e
    _asm mov local register
    =:
    _asm mov register local
    _asm mov x register
















    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
    You're trying to create a language syntax like monkeys typing at
    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




    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sat Nov 7 20:14:13 2026
    From Newsgroup: comp.lang.c

    bartc pisze:


    there is also option

    int rand { rand = rand()}

    Which means...?

    check also this you got
    a structure module

    some
    {
    int x;
    }


    some is structure but also may be use as 'type'


    main()
    {
    some;

    some.x = 10;

    some a,b,c;

    a.x = 10 ;

    }

    now get an array of some

    some[Y][X];

    all a function part to it

    some[Y][X] (int v)
    {
    int val;

    for (int j=0; j<Y; j++}
    for (int i=0; i<X; i++}
    {
    some[j][i].val = v;
    }

    }


    some[100][100](3);

    //creates table of 100x100 of some and calls on it so it feels up with 3


    this kinda unnaturat to c cases where you want an array of int stright

    so its good to have also such syntax


    int some[Y][X] (int v)
    {

    for (int j=0; j<Y; j++}
    for (int i=0; i<X; i++}
    {
    some[j][i] = v;
    }

    }

    this one is virtually just the same as




    some[Y][X] (int v)
    {
    int;

    for (int j=0; j<Y; j++}
    for (int i=0; i<X; i++}
    {
    some[j][i] = v;
    }

    }

    some is structure that contains int but anonymous so you dont need to
    name a field just write some = 29

    it also kinda proves that this kind of syntax is more logical probaly on ground of c

    some {int}

    //seems more logical than int some ..but here for historical reasons
    "int some" may be used i think


    NOTE i not "up think" (think up?) those construction i "down think" them
    (think down them?)


    the difference is those are consequences of what c already is but
    watching those lacks c has and like 'listing' them so its thinking don
    not thinking up i could say


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sat Nov 7 20:18:06 2026
    From Newsgroup: comp.lang.c

    fir pisze:

    there is also option

    int rand { rand = rand()}

    Which means...?

    here not if its not clear this above is

    rand //structure/module/function/type/namespace
    {
    int; //anonymous field
    rand = rand(); //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 endless loop by
    mistake - int calling itself in a loop
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sat Nov 7 20:19:38 2026
    From Newsgroup: comp.lang.c

    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
    {
    -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


    good raa huuh?
    i personally like it though i dont yet observed all options here
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sat Nov 7 20:24:08 2026
    From Newsgroup: comp.lang.c

    fir pisze:

    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 ;

    }

    ofc there are also some more subtle things to observe as some is here namespace so in fact i could write


    main()
    {
    some;

    x = 10; //x is in some

    some a,b,c;
    // here i qould rather not write x = 10 becouse i have many
    (assuming the nameles is not included)
    so i would rather write

    a.x = 10 ; b.x=22; //and so on
    //hough more ice version is probbaly to nud use a dot but a x = 23;
    b y = 33; (probably both can be allowed at once)

    }
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sat Nov 7 20:26:23 2026
    From Newsgroup: comp.lang.c

    fir pisze:

    some {int}

    //seems more logical than int some ..but here for historical reasons
    "int some" may be used-a i think

    "may be used also" i meant
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sat Nov 7 20:50:16 2026
    From Newsgroup: comp.lang.c

    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";) }

    at definitions they are not needed but on execution /clien site

    some() mean execute the code in some where

    some;

    means give the value of some (also include namespace if frst time)




    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Sat Nov 7 22:18:20 2026
    From Newsgroup: comp.lang.c

    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
    -aa structure module

    some
    {
    -a int x;
    }


    some is structure but also may be use as 'type'

    Well, those are the same thing.


    main()
    {
    -a some;

    Stop: what have you just declared here?

    -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 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)

    So, what is 'some' /now/?! Is is a function, type or variable? You know
    it would be very easy to explain.

    {
    -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}

    }

    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.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Sat Nov 7 22:23:32 2026
    From Newsgroup: comp.lang.c

    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:

    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.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 04:17:01 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    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.




    well saying some is type is some kind of shortcut

    i mean its like int is type in such expressions like

    int a,b,c ;

    some a,b,c

    some is like int its genarally an extended structure who is also a
    function (can be called) and module (may have defined functions and
    fields in it) , a 'type' (can be used to 'declare' entities) and
    namespace (can be used to import symbols like namespace), and also as
    builti type like int (comes with operators like int)

    in short simplest is to think it as an extended structure probably

    i said its 'type' coz it describes 'type' of given extended structure
    and may be used to 'declare' clones of it but its not strictly a type

    here some work like int

    some a, b, c; //declarations (?)

    int a,b, c; //declarations

    but also may be used anonymous way


    some; //'anonymous' declaration


    if some is

    some
    {
    int x;
    }


    then

    some a,b,c;

    you may use a.x = 2, b.x=3


    and in case of

    some;

    you can use some.x

    im strictly not 100% sure it should work this 'dychotomic' way
    but im presently closer to the opinion it should, than to opinion it
    shouldnt


    instead of naming some type maybe i should name it as prototype,
    (which probably has much more sense )
    im not sure but i heard once that there are languages who use prototypes instead of types and maybe it is something like that here too , i dont
    know (never checked this topic)

    so if some is extended structure you may just make arrays of it


    some[20] //aray of 20 somes

    some[20] a //array of 30 somes named a
    some b[] //array of 20 somes named b[]


    (also im not sure as this dychotomy if it should go b
    possibly... it may have soem advantage like a
    may define a functions that work on array and b
    defines functions whose only work on ba and you got array of it
    though im not yet strictly sure how to use this potential dichotomy

    eventually in simple case they are both an array of somes making some
    newsome and rules of some fit here,

    the most basic is obviously

    some[20]{
    int a ,b,c
    }
    //array of 20 extended structures some contaiing int a,b,c each







    -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.



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 04:20:22 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    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!


    for two different first two are the same (its definition of local
    extended structure rand).. the third indeed is rand from clib

    its easier to think some is extended structure nearly all in raa is
    extended structure (but also may name it as module or entity, too)
    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.



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 04:36:53 2026
    From Newsgroup: comp.lang.c

    fir pisze:

    No, try it like this first:

    -a-a int A() {B = C()}

    no this should be

    int A() {A = C()}

    now its ok

    if

    C(){2} //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

    int 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} //module A definition

    A(10) //asigns 20 to A

    int X = A*A; //assigns 400 to X



    in fact tha call C() is ignored as there is no code to execute in C but
    C value is taken



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 04:46:33 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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



    if you dont understand it its like

    sinf(); ///calls sinf() function but the result is not 'returned'
    but its a float named sinf


    sou you can
    sinf(1.22);

    float a = sinf*20;


    and in sinf definition you use this syntax

    float sinf(float a)
    {
    //do calculations here

    sinf = //..... result
    }

    so

    int rand { rand = clib_rand()}

    then rand() //cals rand

    a = rand*rand //uses value (witthout calling

    in fact tha call C() is ignored as there is no code to execute in C-a but
    C value is taken




    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Richard Harnden@richard.nospam@gmail.invalid to comp.lang.c on Sun Nov 8 09:29:12 2026
    From Newsgroup: comp.lang.c

    On 07/11/2026 19:19, fir wrote:
    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

    It appears that you've missed reduce/reduce from your list.

    {
    -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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Sun Nov 8 11:19:43 2026
    From Newsgroup: comp.lang.c

    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 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

    -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:

    F = A(3) # generate a new function equivalent to C()*3

    F() # 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.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 12:44:28 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    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'?


    C ad A arestructures and functions at once

    C() {2} (Or
    C{2} is the same as you may skip () in definiton if they are empty)

    you may both call or read its value


    C(); ///you call it //it has no code so it do nothing

    int a = C*C ; //you read it

    now function not return values so if you call C code
    it just sets the value of C which you may use and reuse but there is no
    return in this examples




    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?


    A is both a function and a variable (structure/module)

    its like say "int a" you know what int a is? but you mayy ad code to it

    int a (int b) { a=2<<b }

    now

    a; //means you declare a (if first time in scope)

    a(10); // means you declare and call, a(10) will set it to 1024

    printf("%d", a*3); //printfs 3072





    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.



    no i dont think so it has something to do with it it just a function
    calls involved

    int A(int B) {A = C()*B}

    its like in classic c

    int C() {return 2}

    int A(int B)
    {
    return C()*B;

    }

    the difference is you not return values but you assign it to A (which is
    like "int A" ) and then you may use A as int..also difference is you can
    do more here (on which i was writing a lot before)

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 12:56:35 2026
    From Newsgroup: comp.lang.c

    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 13:12:07 2026
    From Newsgroup: comp.lang.c

    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 like {2,3,4,5, -1,0,4} 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)





    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 16:12:30 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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)

    one coud say that if

    int a (int b)
    {
    a = b;
    }


    is liek

    "int a"(int b)

    ile float f(int b)
    is like "float f"(int b)

    then

    C(int a)

    is like void C(int a)

    thus C{2} is void C{2} then C shouul yeild to void
    and thise are kinda rgiht arguments

    but c is not only variable its alos a structure

    C(int x)
    {
    int a;
    int b;
    int c;
    }


    is like struct C {int a,b,c} so in this view c{2} is more like one
    element structure that contains 2 so probably c{2} is standable but this arguments above is to reember maybe

    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)






    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 16:20:03 2026
    From Newsgroup: comp.lang.c

    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 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


    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


    in fact tha call C() is ignored as there is no code to execute in C
    but C value is taken





    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Sun Nov 8 17:18:19 2026
    From Newsgroup: comp.lang.c

    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

    int randv;

    int randf() {
    randv = rand(); // from stdlib.h
    }

    randf(); // calls rand and store in randv

    a = randv*randv; // 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 = rand()**2;

    C doesn't have '**' now, but this is much more useful and general
    purpose extension. Or you can emulate it:

    int sqrint(int a) { return 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.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 19:17:05 2026
    From Newsgroup: comp.lang.c

    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 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.


    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)

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 19:36:26 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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)


    (side note)

    besides im happy with all that yet becouse other reasons ,

    it SHOWS interesting things, and it RESOLVES some things

    for example as you maybe noticed if rear wat was written that

    if some have

    foo(){

    }

    it SHOWS that in definition those () could be ommited


    foo{
    printf("dsadsad");
    }

    when you call you still need foo(), but not in definition


    its true - and i not saing that - that was a 'result'
    it also byt resolves a thing what such foo {} should be (which was a
    HARD HARD questions back then)

    i like such cases when things answers themselves... its also some form
    of acknovledgment things are done good here when things answers themselves


    (end of side note)


    some can also be said on word declaration becouse now that word
    like has o sense probebly you got definition and you got something like
    "first appearance" or maybe "include" ? instead of declaration

    also such form is generally nice

    foo{
    aaa{
    bb{}
    }
    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)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Sun Nov 8 19:41:02 2026
    From Newsgroup: comp.lang.c

    fir pisze:

    also such form is generally nice

    foo{
    -a aaa{
    -a-a-a bb{}
    -a-a }
    -a zoo{}
    booo{}
    }


    and what it is in 'normal' c? i dont even know

    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)

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Mon Nov 9 23:47:59 2026
    From Newsgroup: comp.lang.c

    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 {} //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 )

    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 {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 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 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?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Mon Nov 9 23:56:52 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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}


    sorry i wrote i ^ 100 here my reader puts superscript here
    if i would sue superscript then i would probably superscriopt whole
    "100i" like {}"100i" not saying its a good idea ..though sometimes it
    seems interesting like tab[i++]^100 = 0 or matbe tab[i++]^100 =
    tab2[k--]^100 (it would be copying with reversing

    overally this analogy using power as analogy fo r loop seems interesting

    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?

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Tue Nov 10 01:11:51 2026
    From Newsgroup: comp.lang.c

    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++) {}"

    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):

    for i=0,strlen(a) {a[i]==0 ? break}

    (I won't comment on that ? construct.)


    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}

    for i=1,100 {tab[i]=0}


    its not quite as natural as-a {tab[i++]=0}^100 but maybe its standable as

    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().)

    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 )

    for i=10,100 {tab[i] = 0}

    Everyone can see it is a for loop.



    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?

    A loop index is definitely a thing, just not in C because it is so
    backward. Even Fortran had it in the 1950s:

    do x i=1,100 # inclusive range

    (x is a label for the end of the loop as it didn't have block syntax yet.)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From David Brown@david.brown@hesbynett.no to comp.lang.c on Tue Nov 10 09:24:35 2026
    From Newsgroup: comp.lang.c

    On 10/11/2026 02:11, bartc wrote:
    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.

    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.)

    (And before you say it, this is not a "workaround". Macros are part of
    the language - they are there to be used if the programmer thinks the resulting code is better. I personally don't think such a "For" macro
    would give better code, but my preferences are different from yours.)


    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

    Symbols are fine for things that are used a lot. For rarely used
    features, they are hard to remember when either reading or writing the
    code. And this would never be used.



    So a repeat-N-times loop. Try ntimes 10 {}

    #define NTimes(_n) for (int _nnn = 0; _nnn < _n; _nnn++)


    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.)


    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. Fir does not need to consider that at all in his ramblings - he
    just lets his cat wander across his keyboard. For a real language for widespread use, it is far more difficult as you have to consider all conceivable corner cases or strange usage. (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. That's
    entirely fine for your own use - but it is one of the reasons your
    language design does not scale or compare to mainstream languages.
    Still, I would far rather work with your choices than Fir's here!)


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Tue Nov 10 12:08:28 2026
    From Newsgroup: comp.lang.c

    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-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

    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).

    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,

    The examples I gave here were just starting points: saner ideas
    (compared to /needing/ Unicode for identifiers for example). But they
    are based on real features used elsewhere.

    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.

    0-based languages make ranges a little more ambiguous. (I believe Zig
    held back on having an iterative for-statement because of this, since
    the upper bounds usually needs to be exclusive.)

    Or do you mean that what I have is not as flexible as a C-style
    for-loop? That would be true. The nearest thing I have to:

    for (A; B; C) {

    is:

    A
    while B, C do

    (This had been a suggested replacement for C's for-loop, which I
    implemented as a proof-of-concept. I decided to keep the feature and use
    it for linked-list traversal, the primary use-case when people explain
    why C for-loops are better.)

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Keith Thompson@Keith.S.Thompson+u@gmail.com to comp.lang.c on Tue Nov 10 04:29:14 2026
    From Newsgroup: comp.lang.c

    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.
    --
    Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
    void Void(void) { Void(); } /* The recursive call of the void */
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From David Brown@david.brown@hesbynett.no to comp.lang.c on Tue Nov 10 13:50:50 2026
    From Newsgroup: comp.lang.c

    On 10/11/2026 13:08, bartc wrote:
    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).

    Well, it works perfectly well in that it does exactly what you are
    asking for here. It is common to have small libraries with functions, headers, macros, typedefs, inline static functions, etc., that you
    re-use between projects. And if you really want such a "For" feature,
    because you really don't like C's "for" loops, and its your code, then
    use it. No one else gets to tell you how you write your own code.

    But if the code is to be shared with others, then you have to consider
    what suits those other people. And if you are sharing small bits of
    code on Usenet (or other discussion forum), it is a lot easier if the
    code is written in a fashion familiar to other people, without extra abstractions, and certainly without extra dependencies. That's nothing special about C or macros - it's just basic communication skills.


    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.


    Agreed. I have no idea what he is actually interested in, and don't
    bother replying to him. (I might follow-up on a post he makes if I
    think it is interesting in the C context or could be of interest to
    someone else here, but I think trying to figure out what he wants or
    trying to help him directly is a lost cause.)

    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.

    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. It is one of the key reasons why you get in arguments with
    so many people here (the other being that your language has no relevance
    to comp.lang.c, or anyone other than yourself). It is fine to /prefer/
    one construct or syntax over another, or to think that one fits better
    in a given language. It is quite a different matter to claim that your
    way is "right" and everyone else is "wrong".


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 13:51:32 2026
    From Newsgroup: comp.lang.c

    bartc pisze:

    -a for i=1,100 {tab[i]=0}



    this on i dont like better woud be imo

    for 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

    { } ^ 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 {} //read like 10 times "power" {} indexed by t

    against


    t ^ 10 {} //same

    then the first one seems more appropriate


    also

    1..29 ^ t {}

    a..b ^ i {}

    imo this above is beter than

    int i =a,b {} //<-- 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..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..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 {tab[t]=9}

    1..29 {tab[%1]=9}

    // maybe 1..29 ^ {tab[%1]=9}
    //maybe ^ t =1..29 {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


    { f(t)} ^ t = {2,7,9,7,2,4,5}




    { 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} ;

    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} ;

    foo(::T);

    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

    foo(^{2,3,4,6}, ^{0,0,3,4});


    foo(^{{2,0}{3,0}{4,3}{6,4}});

    its also ok it semms you can pass it to whole block

    { } ^ 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








    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From David Brown@david.brown@hesbynett.no to comp.lang.c on Tue Nov 10 13:57:43 2026
    From Newsgroup: comp.lang.c

    On 10/11/2026 13:29, Keith Thompson wrote:
    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.


    For a feature that really is useful, and where the change really does
    make a big difference to the language, then I agree. A key indicator of
    that is when people /do/ make multiple incompatible definitions to
    provide the feature. (Booleans is a prime example for C.) When it is a
    minor matter that few people even think about, such as the way "for"
    loops are written in C, then it is entirely unrealistic to imagine it
    being added to the language. Given that, I think it would be better for
    bart to make and use a "For" macro in his own C programming (if he does
    any now), rather than getting annoyed about how "for" works. It would
    be even better for him to simply use C's "for" /without/ getting
    annoyed, if that is an option.



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 14:08:12 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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



    ok so after those above considerations
    (becouse i know not many can go thru them)

    {} ^ t=2..99; //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 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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 14:17:47 2026
    From Newsgroup: comp.lang.c

    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(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







    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 14:22:00 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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



    allright, so a lot has cleared here
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Tue Nov 10 13:53:59 2026
    From Newsgroup: comp.lang.c

    On 10/11/2026 12:50, David Brown wrote:
    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.

    Then I don't understand your point here:

    "it is far more difficult as you have to consider all conceivable corner
    cases or strange usage."

    I directly support these kinds of loops:

    endless
    N-times
    while/repeat-until
    iterate over ranges or values
    (a fifth category not relevant here)

    Given those, then the semantics and implementations can be
    straightforward. I can't see the corner cases you mentioned (except when operating at extreme integer values), therefore there is little to get
    wrong.

    BTW, C only directly supports that third category as while/do-while.

    Plus some construction it calls 'for', which is a kind of DIY toolkit
    for constructing any manner of weird and wonderful loops, that cannot be verified for correctness.

    So did C 'get it right' here? Since there are so many ways for /users/
    to inadvertently get it wrong while still ending up with valid syntax ('for(i=0; j<=n; ++k)').

    (I suggested you'd meant the lack of a statement like this in my
    projects. Well, I did have it for a year or two, but having /never/ used
    it, it got dropped.

    Anyway, how does C get away with having 'while' both starting a loop statement, and ending one?!)


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 15:09:33 2026
    From Newsgroup: comp.lang.c

    bartc pisze:
    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().)

    depend how you will define a power of function call

    i just defined if as f()^N is "f();f(); f();...." N times

    hell kno wif i should see this as multiply ..i dont know..it just makes different analogy and this analogy with power seem gave me a good
    results (there was no deep consideration if its some real "powering"
    and why powering not "multiplicying")

    got some feel that multiplication dont quite go here as multiplication
    is like normal thing more (multiplycation is N additions and when you see

    "aaaaaaaaa" its a^9 not a*9
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 15:13:23 2026
    From Newsgroup: comp.lang.c

    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)

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 15:17:40 2026
    From Newsgroup: comp.lang.c

    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

    int LEN = strlen(a);
    int 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



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 15:24:19 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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



    and here if people searchs 'automatic'

    tab[**height][*width] = 9

    (((i replaced ^ for * just here just tow atch how its look like)

    {{}*width}*height

    eventually it could be taken but the pover eventually better )))

    tab[^^height][^width] = 9

    then there is some "layer" and automatic maybe makes feel plastic, and
    manual is a manual






    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Tue Nov 10 14:27:24 2026
    From Newsgroup: comp.lang.c

    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

    -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:

    (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.)

    -aa..b @ i {}

    (i slightly prefer here a..b ^ i {} right now but the exact symbol
    choices can be deferred)
    Have you considered what the construct 'x .. y', if it was part of the
    syntax, could have lots of different uses. For example:

    if x in a..b # test a within a range
    A[i..j] # 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:

    for i in a..b do end

    Which one do you think is clearer? Further, it is possible to do

    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:

    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:

    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:

    for x in tab {}

    For example:

    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!


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 15:32:58 2026
    From Newsgroup: comp.lang.c

    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.

    ye i know, ebverybody would consider it i guess

    but that showed not the point it showed power idea beats the "what loop
    turn is" (at least in my mind)..but it also showed that this "t=2..23"
    in fact stays (but combined with power)


    so imo

    for i=1..100 {tab[i]=0}

    this is wrong becouse its classical basic seeing of the loop

    but

    {tab[i]=0} ^ i=1..100

    kinda wins the bank here (imo) (though still i could say im not sure if
    this "=" here is not a bit problematic (maybe not but maybe}
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 15:44:06 2026
    From Newsgroup: comp.lang.c

    bartc pisze:

    the @i is also missing so you basically have:

    -a x {}

    Wasn't this the syntax for your composite struct/function definition?

    well if x is range than not

    in some cases you strictly need this for sign but in more narrow you dont

    its interesting if some would do

    int i = 100;

    i {tab[i]=0}

    eventually also could go,a d its minimalistic
    (and i considered thse mininal forms long ago but
    if they are like "600 800 tab[%2][%1]=9 " they cant use this
    classic i j k - unles as above, which i here consider first time
    after a context of "pow")

    but its maybe too exaggeration

    like

    a {b++}

    normally is a definition of module a that calls code b++,
    it it showed above a is an int then definition would turn into loop
    execution

    hovever knowing the context of ^ as pow now even that can be considered

    but such code i may be afraid becomes too heavy

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 15:51:59 2026
    From Newsgroup: comp.lang.c

    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 (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 {}

    (i slightly prefer here a..b ^ i {} right now but the exact symbol
    choices can be deferred)
    Have you considered what the construct 'x .. y', if it was part of the syntax, could have lots of different uses. For example:

    -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!



    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



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 16:10:24 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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 {}

    (i slightly prefer here a..b ^ i {} right now but the exact symbol
    choices can be deferred)
    Have you considered what the construct 'x .. y', if it was part of 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


    note becouse this is important to realize:

    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







    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 16:24:11 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    fir pisze:
    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 {}

    (i slightly prefer here a..b ^ i {} right now but the exact symbol
    choices can be deferred)
    Have you considered what the construct 'x .. y', if it was part of
    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


    note becouse this is important to realize:

    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


    so it by incident maybe lead also to this conlusion


    int A = 10;

    A {printf("*");} //not a loop.. dont know what it is but not a loop


    int t={2,4,5};

    t {printf("%d", t);} //eventually a loop (no ^ needed though it may be
    handy imo)

    though this above is not needed if

    printf("%d", t); //may be a loop if t is list

    if so there is also a need to mke difference where printf takes a
    "spacial" ram list and when it takes "temporal" cascade

    printf("%d", ^t);

    this can be used for temporal cascade but strictly it may not always be needed..other form of distinguish here may play


    so in fuct such

    any expresion containing t - if t is this temporal cascade (scope or
    list ) may be a loop

    char* a = "ssdd";
    char* b= "SDDSDSD"

    a=b;

    may be a loop
    only need to say a or b is temporal cascade (more on this later)












    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 16:38:22 2026
    From Newsgroup: comp.lang.c

    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)



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 16:54:42 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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)


    co the question how to realize strcopy by the use of temporal cascades idea


    char tab[200];
    char tabb[150];

    if one of this is temporal cascade it would be unwind as loop of calls
    in time

    tab[0..100] = tabb[0..100];

    would be loop


    tab[0..199] = tabb[0..199];

    alos would be loop but it reads after the legal ram


    if(!tab[0..149]=tabb[0..149]) break;

    thet could break the loop but assuming what the loop spans
    and im not sure if its obvious

    maybe it should be


    { if(!tab[0..149]=tabb[0..149]) break; }

    or

    { int i = 0..149;
    if(!tab[i]=tabb[i]) break; }


    it all seem long becouse it just seem you can just throw tab or tabb as
    a temporal cascades just stright

    {^tab=^tabb?:break} //break on 0

    depending how to note "throw array as an temporal cascade"

    maybe simple name of tab without [] could be a throwing as temporal
    cascade so in that case

    {tab=tabb?:break} would be temporal strcopy by self

    (i said temporal strcopy coz there is alos imaginable spacial strcopy
    but pc's today have onl temporal afair)









    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 17:09:41 2026
    From Newsgroup: comp.lang.c

    fir pisze:

    -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
    unwind 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)








    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 17:16:42 2026
    From Newsgroup: comp.lang.c

    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
    -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


    int row = 0..799;
    int rows= 0..599;

    tab[^^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


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From fir@profesor.fir@gmail.com to comp.lang.c on Tue Nov 10 17:20:46 2026
    From Newsgroup: comp.lang.c

    fir pisze:
    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



    sorry for a bit of chaotic chain of observations.. i need to rest,
    sme conclusions are taken so it will be more clear next time
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Tim Rentsch@tr.17687@z991.linuxsc.com to comp.lang.c on Tue Nov 10 08:57:27 2026
    From Newsgroup: comp.lang.c

    Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

    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, [...]

    Your statement is clear about what you want. Do you have any
    reasons to offer why anyone else should want it, or is it merely
    a statement of personal opinion?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Tim Rentsch@tr.17687@z991.linuxsc.com to comp.lang.c on Tue Nov 10 11:47:45 2026
    From Newsgroup: comp.lang.c

    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?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From bartc@bc@freeuk.com to comp.lang.c on Tue Nov 10 20:33:42 2026
    From Newsgroup: comp.lang.c

    On 10/11/2026 19:47, Tim Rentsch wrote:
    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?


    Mine was a light-hearted remark. Still, it /does/ get away with using
    the same keyword for two different purposes.

    So you, or a compiler, encounters 'while': is that starting a new
    while-loop, or terminating a do-while loop? A fragment like this:

    ...
    while (*s++ = *t++);

    could be either unless you know what '...' is.

    You need to delve into the grammar to see how it works:

    do stmt while(); // 'while' terminates 'do'

    do while() ... // 'while' is a while-loop inside do-while

    ... while() // independent while-loop provided this is
    // not that first case

    So the 'while' on the first line will get consumed when parsing 'do stmt while' before it can be interpreted as a stand-alone statement.

    The cost is needing to always have exactly 1 statement for the body of do-while. 2 or more need a compound statement, and 0 statements is not allowed.

    (I can't have repeat-while in my own projects because it would be
    ambiguous. But there I can have 0, 1 or more statements within the body,
    and any can legally be nested while-statements.

    I have to use repeat-until which has the opposite logic.)


    --- Synchronet 3.22a-Linux NewsLink 1.2