IRC Log - 2025-03-01

01:45:08 ##forth <cleobuline> ForthBot: : FIBONACCI 1 + DUP 1 = IF DROP 0 EXIT THEN DUP 2 = IF DROP 1 EXIT THEN 0 1 ROT 0 DO OVER + SWAP LOOP NIP ;

01:45:42 ##forth <cleobuline> : recunacci 0 DO I FIBONACCI LOOP .S ;

01:45:50 ##forth <cleobuline> ForthBot: recunacci

01:45:51 ##forth <ForthBot> Unknown word: recunacci

01:46:21 ##forth <cleobuline> : toto 0 DO I FIBONACCI LOOP .S ;

01:46:38 ##forth <cleobuline> ForthBot: : recunacci 0 DO I FIBONACCI LOOP .S ;

01:46:46 ##forth <cleobuline> ForthBot: recunacci

01:46:47 ##forth <ForthBot> Stack: 0

01:47:08 ##forth <cleobuline> ForthBot: 10 FIBONACCI .

01:47:09 ##forth <ForthBot> 55

01:47:53 ##forth <cleobuline> ForthBot: FLUSH 20 recunacci

01:47:54 ##forth <ForthBot> Stack: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

01:50:53 ##forth <cleobuline> ForthBot: WORDS

01:50:53 ##forth <ForthBot> SUM_SQUARE ? X FIBONACCI recunacci

08:33:05 ##forth <veltas> xentrac: The architecture's not been a huge focus but I am inspired by local building a little. For instance I live in a terraced house, I never see that in a city sim

08:33:33 ##forth <veltas> So I will definitely generate terraces of different lengths

08:34:06 ##forth <veltas> And I want buildings to fill arbitrary plots better than most sims do

08:34:19 ##forth <user51> Call it Grand Theft Fortho

08:34:22 ##forth <veltas> But I also can't 'shape' skyscrapers much, they're usually simple shapes

08:34:31 ##forth <veltas> So I won't

08:35:53 ##forth <veltas> user51: I had thought about using Forth, but currently am not using it at all because I'm not as productive in it

08:36:09 ##forth <veltas> And the point of this exercise is not playing with Forth, but actually getting stuff done

08:36:45 ##forth <veltas> I think Forth would be great for a retro programming puzzles game though

08:37:24 ##forth <vms14> as a scripting lang

08:37:28 ##forth <veltas> Arguably a sort of higher-level 'runtime-checked' Forth would be decent for scripting, if you had scripters on a project

08:38:08 ##forth <veltas> I don't presently have any scripters planned or necessary for this city sim, if I needed that I'd use Lua, but I don't think it will be necessary at all

08:38:09 ##forth <user51> Come on, it needs to be statically-checked formally-verified and provably-terminating :P

08:38:12 ##forth <veltas> luajit specifically

08:48:06 ##forth <veltas> Also I'm not saying Forth is always less productive, but for me it's not been that productive. Arguably classic Forth isn't that productive, inherently.

08:48:34 ##forth <veltas> And this is why I'm always more interested in what people like crc have done, because they put their own dialects into practice and have demonstrated more

08:50:53 ##forth <veltas> e.g. retro and konilo's environments are quite featured, and crc seems to be able to put stuff together relatively quickly in his environments

08:50:53 ##forth <veltas> Although that could be an illusion!

08:54:09 ##forth <veltas> But also we're all different, I could just be bad at it

11:01:25 ##forth <cleobuline> helllo

11:05:24 ##forth <veltas> Hi

11:06:37 ##forth <cleobuline> ForthBot: WORDS

11:06:37 ##forth <ForthBot> SUM_SQUARE ? X FIBONACCI recunacci HAMLET

11:07:25 ##forth <cleobuline> ForthBot: SEE HAMLET

11:07:25 ##forth <ForthBot> : HAMLET (OP_42) (OP_42) (OP_42) ;

11:07:58 ##forth <cleobuline> ForthBot: FORGET HAMLET

11:10:53 ##forth <user51> ForthBot: FORGET FORGET

11:10:53 ##forth <ForthBot> FORGET: Unknown word: FORGET

11:14:25 ##forth <cleobuline> ForthBot: SEE HAMLET

11:14:26 ##forth <ForthBot> SEE: Unknown word: HAMLET

11:14:42 ##forth <cleobuline> ForthBot: WORDS

11:14:42 ##forth <ForthBot> SUM_SQUARE ? X FIBONACCI recunacci

11:16:26 ##forth <user51> Does it do regex? FORGET .* :P

11:30:56 ##forth <user51> I'm looking for a specific quote -- I believe it's from Chuck, it's about quantisizing your code or data, can't remember which. Does anyone have a clue?

12:40:54 ##forth <pgimeno> ForthBot: 5 3 AND .

12:40:54 ##forth <ForthBot> 1

12:42:27 ##forth <cleobuline> ForthBot: 5 3 & .

12:42:28 ##forth <ForthBot> 1

12:43:13 ##forth <cleobuline> ForthBot: 5 3 | .

12:43:13 ##forth <ForthBot> 7

12:44:05 ##forth <cleobuline> ForthBot: 5 3 ~ .

12:44:05 ##forth <ForthBot> Unknown word: ~ .

12:44:25 ##forth <cleobuline> ForthBot: 5 3 ~ .

12:44:26 ##forth <ForthBot> -4

12:45:31 ##forth <cleobuline> ForthBot: 5 LSHIFT .

12:45:31 ##forth <ForthBot> 160

12:45:50 ##forth <cleobuline> ForthBot: 5 2 LSHIFT .

12:45:50 ##forth <ForthBot> 20

12:56:26 ##forth <cleobuline> ForthBot: 2 16 LSHIFT .

12:56:26 ##forth <ForthBot> 131072

12:56:48 ##forth <cleobuline> bizarre

12:56:59 ##forth <cleobuline> ForthBot: FLUSH

12:57:07 ##forth <cleobuline> ForthBot: 2 16 LSHIFT .

12:57:08 ##forth <ForthBot> 131072

12:57:20 ##forth <cleobuline> ForthBot: 1 16 LSHIFT .

12:57:20 ##forth <ForthBot> 65536

12:57:25 ##forth <cleobuline> c'st mieux

13:55:32 ##forth <pgimeno> ForthBot: : test 0 BEGIN 1+ DUP 5 = UNTIL . ;

13:55:32 ##forth <ForthBot> Unknown word: 1+

13:55:39 ##forth <pgimeno> ForthBot: : test 0 BEGIN 1 + DUP 5 = UNTIL . ;

13:55:39 ##forth <ForthBot> Unknown word: UNTIL

13:56:11 ##forth <pgimeno> ForthBot: : test 0 BEGIN 1 + DUP 5 <> WHILE REPEAT . ;

13:56:12 ##forth <ForthBot> Unknown word: <>

13:56:18 ##forth <pgimeno> ForthBot: : test 0 BEGIN 1 + DUP 5 = 0 = WHILE REPEAT . ;

13:56:26 ##forth <pgimeno> ForthBot: test

13:56:44 ##forth <pgimeno> ForthBot: .S

13:56:44 ##forth <ForthBot> Stack empty

13:58:10 ##forth <KipIngram> That should be 5, shouldn't it?

13:58:27 ##forth <pgimeno> yes but nothing came up

13:58:41 ##forth <pgimeno> I was testing if loops worked

13:59:29 ##forth <pgimeno> ForthBot: 0 5 = . 5 5 = .

13:59:29 ##forth <ForthBot> 0

14:02:16 ##forth <GeDaMo> ForthBot: test .S

14:02:16 ##forth <ForthBot> Stack empty

14:02:29 ##forth <GeDaMo> I was wondering if the stack was cleared afor eah line

14:03:08 ##forth <ghodawalaaman> ForthBot: 1

14:03:11 ##forth <ghodawalaaman> ForthBot: .S

14:03:11 ##forth <ForthBot> Stack: 1

14:03:18 ##forth <ghodawalaaman> GeDaMo: nope it doesn't

14:03:19 ##forth <cleobuline> yet there is still some bugs , i am working on them for now

14:03:41 ##forth <cleobuline> .S does not empty the stack

14:08:30 ##forth <pgimeno> I wanted to write a Collatz length finder, taking advantage of the bignum support, but I don't want to make it recursive, so it can't be done without loops

14:18:40 ##forth <user51> pgimeno: http://0x0.st/8mhp.forth

14:19:08 ##forth <cleobuline> ForthBot: : COUNTDOWN DUP BEGIN DUP . CR 1 - DUP 0 > WHILE REPEAT DROP DROP ;

14:19:17 ##forth <cleobuline> ForthBot: 3 COUNTDOWN

14:19:17 ##forth <ForthBot> 3

14:19:32 ##forth <cleobuline> ForthBot: 3 COUNTDOWN

14:19:32 ##forth <ForthBot> 3

14:19:49 ##forth <user51> pgimeno: extra credit if you make it memoize numbers to avoid recalculations.

14:20:15 ##forth <cleobuline> ForthBot: FORGET COUNTDOWN

14:20:32 ##forth <user51> cleobuline: does ForthBot have variables or values?

14:20:45 ##forth <cleobuline> yes it have

14:20:55 ##forth <cleobuline> ForthBot: VARIABLE X

14:21:03 ##forth <user51> ForthBot: 0 VALUE T

14:21:03 ##forth <ForthBot> Unknown word: VALUE

14:21:33 ##forth <cleobuline> ForthBot: 123456789123456789 X !

14:21:43 ##forth <cleobuline> ForthBot: X @ .

14:21:43 ##forth <ForthBot> 123456789123456789

14:22:28 ##forth <cleobuline> ForthBot: : COUNTDOWN DUP BEGIN DUP . CR 1 - DUP 0 > WHILE REPEAT DROP DROP ;

14:22:38 ##forth <cleobuline> ForthBot: 3 COUNTDOWN

14:22:38 ##forth <ForthBot> 3

14:22:43 ##forth <cleobuline> bug

14:24:22 ##forth <cleobuline> ForthBot: : COUNTDOWN DUP BEGIN DUP . CR 1 - DUP 0 > WHILE REPEAT DROP DROP ; 3 COUNTDOWN .

14:24:23 ##forth <ForthBot> 3

14:24:23 ##forth <ForthBot> Stack empty

14:24:34 ##forth <cleobuline> seem some memory corruption

14:24:49 ##forth <user51> ForthBot: VARIABLE DOWN : COUNTDOWN ( N -- ) DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! DOWN @ REPEAT ; 5 COUNTDOWN

14:24:49 ##forth <ForthBot> Unknown word: (

14:25:03 ##forth <user51> ForthBot: VARIABLE DOWN : COUNTDOWN DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! DOWN @ REPEAT ; 5 COUNTDOWN

14:25:03 ##forth <ForthBot> Unknown word: ?

14:25:11 ##forth <cleobuline> no ( ) for now

14:25:13 ##forth <user51> oh come on. the bot is ddosing me

14:25:57 ##forth <user51> gforth_eval_bot: VARIABLE DOWN : COUNTDOWN ( N -- ) DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! DOWN @ REPEAT ; 5 COUNTDOWN

14:26:13 ##forth <user51> !gforth VARIABLE DOWN : COUNTDOWN ( N -- ) DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! DOWN @ REPEAT ; 5 COUNTDOWN

14:26:14 ##forth <gforth_eval_bot> 5 4 3 2 1

14:26:20 ##forth <pgimeno> user51: I don't think there's much value in memoizing for Collatz sequences. Ackermann on the other hand...

14:26:43 ##forth <user51> pgimeno: never seen ackerman in the wild outside of SICP

14:27:20 ##forth <cleobuline> ForthBot: VARIABLE DOWN : COUNTDOWN DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! DOWN @ REPEAT ; 5 COUNTDOWN

14:27:40 ##forth <pgimeno> ForthBot: WORDS

14:27:47 ##forth <pgimeno> oh quit

14:27:50 ##forth <cleobuline> leaving .

14:27:53 ##forth <user51> cleobuline: maybe the bot should scan for !prefix like gforth_eval_bot

14:28:25 ##forth <cleobuline> ForthBot: VARIABLE DOWN : COUNTDOWN DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! DOWN @ REPEAT ; 5 COUNTDOWN

14:28:25 ##forth <ForthBot> Unknown word: ?

14:28:35 ##forth <user51> ForthBot: : ? @ . ;

14:29:05 ##forth <cleobuline> FORGET COUNTDOWN

14:29:13 ##forth <cleobuline> ForthBot: FORGET COUNTDOWN

14:29:21 ##forth <pgimeno> ForthBot: WORDS

14:29:21 ##forth <ForthBot> DOWN

14:29:25 ##forth <cleobuline> : COUNTDOWN DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! DOWN @ REPEAT ; 5 COUNTDOWN

14:29:39 ##forth <cleobuline> ForthBot: .S

14:29:39 ##forth <ForthBot> Stack: 0 0 4 0 3 0 2 0 1 0 0

14:29:44 ##forth <cleobuline> lol

14:29:44 ##forth <user51> good thing i didn't use 1- there :D

14:31:38 ##forth <pgimeno> are there any known Forth implementations that interleave the data and return stacks?

14:33:31 ##forth <user51> pgimeno: what does that mean in practice?

14:36:32 ##forth <pgimeno> I mean having the even words be the return stack and the odd words be the data stack or vice versa

14:36:47 ##forth <pgimeno> so both can grow down

14:39:22 ##forth <pgimeno> that implies possibly better cache locality, and no need to allocate one of them separately from the other or move it around

14:41:34 ##forth <GeDaMo> Might be wasteful if you're pushing more to the data stack than return

14:41:52 ##forth <GeDaMo> In that case, it also wouldn't be better for locality

14:45:01 ##forth <MrMobius> trying to have multiple stacks in limited memory is a headache. for a stack with types, you can add them in any order you like as long as speed isn't critical

14:58:38 ##forth <user51> Any good tests for word parsing? Specifically, getting the next word from the scanned line. I figured there aren't that many cases since since we have 2 types of characters (parsed and skipped), that's one bit, and with some wishful thinking on my end I could generate some bit pattern tests that might cover enough cases to give some confidence it works well. Or I'm probably being too perfectionist here,

14:58:44 ##forth <user51> also a good answer :)

15:37:40 ##forth <cleobuline> corrected some bugs

15:38:15 ##forth <cleobuline> ForthBot: : ? @ . ;

15:38:38 ##forth <cleobuline> ForthBot: ForthBot: VARIABLE DOWN

15:38:38 ##forth <ForthBot> Unknown word: ForthBot:

15:38:52 ##forth <cleobuline> ForthBot: VARIABLE DOWN

15:39:12 ##forth <cleobuline> ForthBot: : COUNTDOWN DUP DOWN ! BEGIN DOWN @ 0 > WHILE DOWN ? DOWN @ 1 - DOWN ! REPEAT DROP ;

15:39:20 ##forth <cleobuline> ForthBot: 3 COUNTDOWN

15:39:21 ##forth <ForthBot> 3

15:39:26 ##forth <cleobuline> nice

15:40:00 ##forth <ghodawalaaman> 5 COUNTDOWN

15:40:10 ##forth <ghodawalaaman> ForthBot: 5 COUNTDOWN

15:40:10 ##forth <ForthBot> 5

15:40:14 ##forth <ghodawalaaman> :o

15:40:27 ##forth <cleobuline> ForthBot: : FACT DUP 1 > IF DUP 1 - FACT * ELSE DROP 1 THEN ;

15:40:27 ##forth <ghodawalaaman> 100000000000 COUNTDOWN :>

15:40:35 ##forth <cleobuline> noooooo !!!!

15:40:43 ##forth <ghodawalaaman> lol

15:40:57 ##forth <cleobuline> ForthBot: 20 FACT .

15:40:57 ##forth <ForthBot> 2432902008176640000

15:41:02 ##forth <cleobuline> nice

15:41:21 ##forth <user51> ForthBot: : TEST ( n -- ) DOWN ! DOWN @ 0 > IF DOWN ? DOWN @ 1 - DOWN ! RECURSE THEN ; 5 TEST

15:41:22 ##forth <ForthBot> Unknown word: (

15:41:27 ##forth <cleobuline> ForthBot: FORGET

15:41:28 ##forth <ForthBot> FORGET requires a word name

15:41:38 ##forth <cleobuline> ForthBot: FORGET COUNTDOWN

15:41:52 ##forth <ghodawalaaman> ForthBot: 5 COUNTDOWN

15:41:52 ##forth <ForthBot> Unknown word: COUNTDOWN

15:41:55 ##forth <cleobuline> il ha not implemented comment ( )

15:42:14 ##forth <cleobuline> not recurse too

15:42:29 ##forth <cleobuline> just call the definition directly

15:42:37 ##forth <ghodawalaaman> did you make it from scratch?

15:42:46 ##forth <cleobuline> yes

15:42:56 ##forth <ghodawalaaman> that's cool :o

15:43:03 ##forth <cleobuline> ForthBot: : test zozo ;

15:43:04 ##forth <ForthBot> Unknown word: zozo

15:43:14 ##forth <cleobuline> ForthBot: WORDS

15:43:15 ##forth <ForthBot> DP ? DOWN

15:43:43 ##forth <cleobuline> before there was undefined words dangling in the disctionnary i fix it

15:45:45 ##forth <cleobuline> i'm 66 retired programing is a hobbie for me to spend some time

15:48:43 ##forth <cleobuline> ForthBot: : FIBONACCI DUP 0 = IF DROP 0 EXIT THEN DUP 1 = IF DROP 1 EXIT THEN DUP 2 = IF DROP 1 EXIT THEN 1 1 ROT 2 - 0 DO OVER + SWAP LOOP DROP ;

15:49:00 ##forth <cleobuline> : RECUNACCI 0 DO I FIBONACCI LOOP DROP ;

15:49:11 ##forth <cleobuline> 10 RECUNACCI .S

15:49:15 ##forth <cleobuline> lol

15:49:29 ##forth <cleobuline> seem in a llop

15:49:36 ##forth <user51> ForthBot: SEE recunacci

15:49:36 ##forth <ForthBot> SEE: Unknown word: recunacci

15:49:44 ##forth <user51> ForthBot: SEE RECUNACCI

15:49:44 ##forth <ForthBot> SEE: Unknown word: RECUNACCI

15:49:48 ##forth <user51> oopsie.

15:50:00 ##forth <cleobuline> ForthBot: WORDS

15:50:00 ##forth <ForthBot> DP ? DOWN FIBONACCI

15:50:53 ##forth <cleobuline> ForthBot: 10 FIBONACCI .

15:50:53 ##forth <ForthBot> 55

15:51:11 ##forth <cleobuline> ForthBot: FLUSH

15:51:20 ##forth <cleobuline> ForthBot: 0 FIBONACCI

15:51:24 ##forth <cleobuline> ForthBot: .

15:51:24 ##forth <ForthBot> 0

15:51:46 ##forth <cleobuline> ForthBot: 1 FIBONACCI .

15:51:46 ##forth <ForthBot> 1

15:51:51 ##forth <crc> veltas: being able to put things together fairly quickly is, for me, the result of spending 25 years working on my dialects, building up the vocabulary, and getting comfortable working with the stacks

15:52:24 ##forth <cleobuline> ForthBot: FLUSH

15:52:57 ##forth <cleobuline> ForthBot: SEE RECUNACCI

15:52:57 ##forth <ForthBot> : RECUNACCI 0 DO I FIBONACCI LOOP DROP ;

15:53:52 ##forth <cleobuline> ForthBot: 10 RECUNACCI .S

15:53:52 ##forth <ForthBot> Stack: 0 1 1 2 3 5 8 13 21

15:54:08 ##forth <cleobuline> ForthBot: 11 RECUNACCI .S

15:54:08 ##forth <ForthBot> Stack: 0 1 1 2 3 5 8 13 21 0 1 1 2 3 5 8 13 21 34

15:54:25 ##forth <cleobuline> mmm

15:54:40 ##forth <cleobuline> something wrong in the loop

15:55:32 ##forth <cleobuline> : RECUNACCI 2 + 0 DO I FIBONACCI LOOP DROP ;

15:55:46 ##forth <cleobuline> ForthBot: : RECUNACCI 2 + 0 DO I FIBONACCI LOOP DROP ;

15:55:57 ##forth <cleobuline> ForthBot: 10 RECUNACCI .S

15:55:58 ##forth <ForthBot> Unknown word: RECUNACCI

15:56:17 ##forth <cleobuline> merde !

15:57:22 ##forth <cleobuline> ForthBot: : test DO I LOOP ;

15:57:34 ##forth <cleobuline> ForthBot: FLUSH

15:57:47 ##forth <cleobuline> ForthBot: 10 0 test .S

15:57:47 ##forth <ForthBot> Stack: 10 0

15:57:59 ##forth <cleobuline> loop is broken

15:58:22 ##forth <cleobuline> back to the store ....

16:02:35 ##forth <cleobuline> ForthBot: : test DO I LOOP ; 10 0 test .S

16:02:36 ##forth <ForthBot> Stack: 0 1 2 3 4 5 6 7 8 9

16:03:10 ##forth <cleobuline> something is corrupting ....

16:08:01 ##forth <user51> !gforth : test DO I LOOP ; 10 0 test .S

16:08:04 ##forth <gforth_eval_bot> <10> 1 2 3 4 5 6 7 8 9

16:32:22 ##forth <veltas> crc: I think also your dialect is more orthogonal and convenient than classic Forths

16:32:42 ##forth <veltas> Although I just get that impression from the programs I've seen, I've still not actually learned it myself

16:35:09 ##forth <user51> veltas: retro?

16:39:56 ##forth <veltas> Yeah retro, I do know classic forth and have used it a fair amount

16:40:03 ##forth <veltas> retro and konilo

17:54:14 ##forth <cleobuline> ForthBot: : FACT DUP 1 > IF DUP 1 - RECURSE * ELSE DROP 1 THEN ;

17:54:14 ##forth <ForthBot> Defined: FACT

17:54:31 ##forth <cleobuline> ForthBot: SEE FACT

17:54:31 ##forth <ForthBot> : FACT DUP 1 > IF DUP 1 - RECURSE * ELSE DROP 1 THEN ;

18:33:50 ##forth <user51> Still a huge bloody mess, but threading seems to work.. for now.

18:34:01 ##forth <user51> http://0x0.st/8aA_.c

18:37:45 ##forth <user51> Here's a sample input/output, first line is the input http://0x0.st/8aA6.txt

20:41:12 ##forth <user51> f

20:42:01 ##forth <user51> Maybe I could prevent my client from sending one letter messages, not idea how tho.

20:58:41 ##forth <cleobuline> ForthBot: : RECUNACCI 0 DO I FIBONACCI LOOP DROP ;

20:58:42 ##forth <ForthBot> Unknown word: FIBONACCI

20:58:51 ##forth <cleobuline> ForthBot: WORDS

20:58:51 ##forth <ForthBot> DP FACT

20:59:22 ##forth <cleobuline> ForthBot: : FIBONACCI DUP 0 = IF DROP 0 EXIT THEN DUP 1 = IF DROP 1 EXIT THEN DUP 2 = IF DROP 1 EXIT THEN 1 1 ROT 2 - 0 DO OVER + SWAP LOOP DROP ;

20:59:23 ##forth <ForthBot> Defined: FIBONACCI

20:59:32 ##forth <cleobuline> ForthBot: : RECUNACCI 0 DO I FIBONACCI LOOP DROP ;

20:59:38 ##forth <cleobuline> ForthBot: : RECUNACCI 0 DO I FIBONACCI LOOP DROP ;

20:59:38 ##forth <ForthBot> Defined: RECUNACCI

20:59:53 ##forth <cleobuline> ForthBot: 10 RECUNACCI

21:00:04 ##forth <cleobuline> ForthBot: .S

21:00:04 ##forth <ForthBot> Stack: 0 0 1 1 2 3 5 8 13 21

21:00:30 ##forth <cleobuline> mm

21:00:45 ##forth <cleobuline> ForthBot: 1 FIBONACCI .

21:00:45 ##forth <ForthBot> 1

21:01:07 ##forth <cleobuline> ForthBot: FLUSH

21:01:15 ##forth <cleobuline> ForthBot: 10 RECUNACCI

21:01:20 ##forth <cleobuline> ForthBot: .S

21:01:20 ##forth <ForthBot> Stack: 0 1 1 2 3 5 8 13 21

21:01:46 ##forth <cleobuline> ForthBot: 11 RECUNACCI .S

21:01:46 ##forth <ForthBot> Stack: 0 1 1 2 3 5 8 13 21 0 1 1 2 3 5 8 13 21 34

21:03:27 ##forth <cleobuline> ForthBot: FLUSH

21:04:39 ##forth <cleobuline> ForthBot: : RECUNACCI 1 + 0 DO I FIBONACCI LOOP DROP ;

21:04:40 ##forth <ForthBot> Defined: RECUNACCI

21:04:58 ##forth <cleobuline> ForthBot: 10 RECUNACCI .S

21:04:58 ##forth <ForthBot> Stack: 0 1 1 2 3 5 8 13 21 34

21:06:58 ##forth <cleobuline> ForthBot: : RECUNACCI 2 + 0 DO I FIBONACCI LOOP DROP ;

21:06:58 ##forth <ForthBot> Defined: RECUNACCI

21:07:04 ##forth <cleobuline> ForthBot: 10 RECUNACCI .S

21:07:05 ##forth <ForthBot> Stack: 0 1 1 2 3 5 8 13 21 34 0 1 1 2 3 5 8 13 21 34 55

21:07:16 ##forth <cleobuline> wright

21:07:45 ##forth <cleobuline> ForthBot: FLUSH

21:08:28 ##forth <cleobuline> f(0)...f(10)

21:11:33 ##forth <cleobuline> ForthBot: WORDS

21:11:33 ##forth <ForthBot> DP FACT FIBONACCI RECUNACCI

21:12:02 ##forth <cleobuline> ForthBot: DP @ .

21:12:02 ##forth <ForthBot> 4

21:31:37 ##forth <cleobuline> ForthBot: 72 EMIT 73 EMIT CR

21:31:38 ##forth <ForthBot> Unknown word: EMIT

21:31:44 ##forth <cleobuline> ah

21:32:00 ##forth <cleobuline> zut

IRC Log - 2025-03-01 - ##forth