Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c > #403919 > unrolled thread
| Started by | fir <profesor.fir@gmail.com> |
|---|---|
| First post | 2026-11-01 14:32 +0100 |
| Last post | 2026-11-03 13:29 +0100 |
| Articles | 20 on this page of 90 — 7 participants |
Back to article view | Back to comp.lang.c
p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-01 14:32 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-01 13:41 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-01 15:10 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-01 16:13 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-02 16:46 +0100
Re: p = {1,0,0} David Brown <david.brown@hesbynett.no> - 2026-11-02 17:36 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-02 18:47 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-02 20:54 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-02 20:56 +0100
Re: p = {1,0,0} David Brown <david.brown@hesbynett.no> - 2026-11-02 21:29 +0100
Re: p = {1,0,0} Janis Papanagnou <janis_papanagnou+ng@hotmail.com> - 2026-11-02 21:39 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-02 22:58 +0000
Re: p = {1,0,0} David Brown <david.brown@hesbynett.no> - 2026-11-03 11:09 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 13:19 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-03 14:07 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 15:45 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 15:54 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 16:48 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 14:29 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 14:42 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 16:09 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 16:18 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 16:38 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 16:55 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 17:06 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-03 16:26 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 17:34 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 17:47 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 17:54 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 22:08 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-04 14:14 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-04 14:27 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-05 19:10 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-05 19:38 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-07 20:14 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-07 20:18 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-07 20:19 +0100
Re: p = {1,0,0} Richard Harnden <richard.nospam@gmail.invalid> - 2026-11-08 09:29 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-07 20:24 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-07 20:26 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-07 22:18 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 04:17 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-07 20:50 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-07 22:23 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 04:20 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 04:36 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 04:46 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 16:20 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-08 17:18 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 19:17 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 19:36 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 19:41 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-08 11:19 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 12:44 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 12:56 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 13:12 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-08 16:12 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-09 23:47 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-09 23:56 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-10 01:11 +0000
Re: p = {1,0,0} David Brown <david.brown@hesbynett.no> - 2026-11-10 09:24 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-10 12:08 +0000
Re: p = {1,0,0} David Brown <david.brown@hesbynett.no> - 2026-11-10 13:50 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-10 13:53 +0000
while() and do/while() Tim Rentsch <tr.17687@z991.linuxsc.com> - 2026-11-10 11:47 -0800
Re: while() and do/while() bartc <bc@freeuk.com> - 2026-11-10 20:33 +0000
Re: p = {1,0,0} Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2026-11-10 04:29 -0800
Re: p = {1,0,0} David Brown <david.brown@hesbynett.no> - 2026-11-10 13:57 +0100
Re: p = {1,0,0} Tim Rentsch <tr.17687@z991.linuxsc.com> - 2026-11-10 08:57 -0800
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 13:51 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 14:08 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 14:17 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 14:22 +0100
Re: p = {1,0,0} bartc <bc@freeuk.com> - 2026-11-10 14:27 +0000
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 15:32 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 15:44 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 15:51 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 16:10 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 16:24 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 16:38 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 16:54 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 17:09 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 17:16 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 17:20 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 15:09 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 15:13 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 15:17 +0100
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-10 15:24 +0100
Re: p = {1,0,0} Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2026-11-02 14:52 -0800
Re: p = {1,0,0} fir <profesor.fir@gmail.com> - 2026-11-03 13:29 +0100
Page 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 16:09 +0100 |
| Message-ID | <11cctee$3rtjh$1@dont-email.me> |
| In reply to | #404025 |
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
>
> foo(){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
>
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 16:18 +0100 |
| Message-ID | <11ccu0t$3s54f$1@dont-email.me> |
| In reply to | #404029 |
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
>>
>> foo(){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}
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
>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 16:38 +0100 |
| Message-ID | <11ccv4n$3sjn5$1@dont-email.me> |
| In reply to | #404031 |
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
>>>
>>> foo(){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}
>
>
> 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
> }
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
>>>
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 16:55 +0100 |
| Message-ID | <11cd05l$3t1er$1@dont-email.me> |
| In reply to | #404032 |
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
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 17:06 +0100 |
| Message-ID | <11cd0q3$3ta28$1@dont-email.me> |
| In reply to | #404034 |
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
>
>
>
>
>
[toc] | [prev] | [next] | [standalone]
| From | bartc <bc@freeuk.com> |
|---|---|
| Date | 2026-11-03 16:26 +0000 |
| Message-ID | <11cd1vs$3tpfp$1@dont-email.me> |
| In reply to | #404035 |
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.
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 17:34 +0100 |
| Message-ID | <11cd2dq$3ttmh$1@dont-email.me> |
| In reply to | #404038 |
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
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 17:47 +0100 |
| Message-ID | <11cd36g$3v5sa$1@dont-email.me> |
| In reply to | #404040 |
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(); 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...
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 17:54 +0100 |
| Message-ID | <11cd3ja$3v9nq$1@dont-email.me> |
| In reply to | #404041 |
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(); 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)
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-03 22:08 +0100 |
| Message-ID | <11cdigl$55s6$1@dont-email.me> |
| In reply to | #404040 |
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(); 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
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-04 14:14 +0100 |
| Message-ID | <11cfb4g$mrpc$1@dont-email.me> |
| In reply to | #404046 |
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(); 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
>
> }
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 //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
>>
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-04 14:27 +0100 |
| Message-ID | <11cfbsg$n4qm$1@dont-email.me> |
| In reply to | #404053 |
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(); 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
>>
>> }
>
>
> 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 //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
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-05 19:10 +0100 |
| Message-ID | <11cigrh$1rt97$1@dont-email.me> |
| In reply to | #404046 |
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(); 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
>
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
>>
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-05 19:38 +0100 |
| Message-ID | <11ciifg$1siu4$1@dont-email.me> |
| In reply to | #404075 |
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(); 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
>>
>
>
> 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
> }
>
>
soory here should be
(int a)=(int b)
{
_asm mov register b
_asm mov a register
}
>
> (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
>
> =(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
>>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-07 20:14 +0100 |
| Message-ID | <11cntae$3nme2$1@dont-email.me> |
| In reply to | #404038 |
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
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-07 20:18 +0100 |
| Message-ID | <11cnthn$3npbi$1@dont-email.me> |
| In reply to | #404131 |
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
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-07 20:19 +0100 |
| Message-ID | <11cntkj$3npbi$2@dont-email.me> |
| In reply to | #404132 |
fir pisze:
> 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
good Ↄ huuh?
i personally like it though i dont yet observed all options here
[toc] | [prev] | [next] | [standalone]
| From | Richard Harnden <richard.nospam@gmail.invalid> |
|---|---|
| Date | 2026-11-08 09:29 +0000 |
| Message-ID | <11cpfd9$6gvq$1@dont-email.me> |
| In reply to | #404133 |
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 its not clear this above is
>>
>> rand //structure/module/function/type/namespace
It appears that you've missed reduce/reduce from your list.
>> {
>> 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
>
>
> good Ↄ huuh?
> i personally like it though i dont yet observed all options here
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-07 20:24 +0100 |
| Message-ID | <11cntt2$3ntj9$1@dont-email.me> |
| In reply to | #404131 |
fir pisze:
>
> some is structure but also may be use as 'type'
>
>
> main()
> {
> some;
>
> some.x = 10;
>
> some a,b,c;
>
> 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)
}
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2026-11-07 20:26 +0100 |
| Message-ID | <11cnu18$3ntj8$1@dont-email.me> |
| In reply to | #404131 |
fir pisze:
>
> some {int}
>
> //seems more logical than int some ..but here for historical reasons
> "int some" may be used i think
"may be used also" i meant
[toc] | [prev] | [next] | [standalone]
Page 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
Back to top | Article view | comp.lang.c
csiph-web