06:56 <Nistur> mornin'

06:56 <mtsd> Good morning!

06:56 <Nistur> o7

06:59 <beneroth> Good morning

07:00 <Nistur> at the weekend, MiniNisturette woke up, looked at me, and said, quite clearly, Qapla'!

07:00 <Nistur> I think I'm raising a Klingon

07:01 <Regenaxer> Hi all :)

07:03 <mtsd> Hi Regenaxer!

08:29 <beneroth> Nistur, congrats to the Klingon :-)

08:29 <beneroth> Hi Regenaxer :)

08:29 <Regenaxer> Hi beneroth

08:29 <beneroth> hey mtsd :)

08:29 <mtsd> Hey :)

08:30 <beneroth> tankf33der, thanks for the tip with b2sum - it is really blazing fast :-)

08:30 <tankf33der> o/

09:14 <tankf33der> i have my own b2sum on picolisp and monocypher via mmap.

10:25 <beneroth> oh nice :D

11:01 <beneroth> Regenaxer, you got a bit time?

11:01 <Regenaxer> yep :)

11:01 <beneroth> what is your recommendation for error handling with (later) ?

11:02 <beneroth> seems to me that evaluation (quit) within (later) results in repl of the (later)-childprocess

11:02 <beneroth> ok, now

11:02 <beneroth> no

11:02 <Regenaxer> yes, it exits

11:03 <beneroth> T

11:03 <Regenaxer> in general quit exits if there is no tty

11:03 <beneroth> so (quit) can be used as usual within (later) ?

11:03 <beneroth> T

11:03 <Regenaxer> yes, errors go to stderr then

11:03 <beneroth> the process which started (later) is also exited, right?

11:04 <beneroth> by quit within later

11:04 <Regenaxer> the parent? No, it is not concerned

11:04 <Regenaxer> it gets EOF

11:04 <Regenaxer> i.e. NIL in the pipe

11:05 <beneroth> so.. nothing, just empty results

11:05 <beneroth> ok...

11:07 <beneroth> I see

11:07 <beneroth> it's visible in (kids)

11:08 <Regenaxer> yes, cause 'pipe' is used

11:08 <Regenaxer> The child is a normal family member

11:09 <beneroth> so best to extend the (wait NIL (full @)) from the (later) example with a timeout limit

11:09 <beneroth> (in practical use, I mean)

11:10 <Regenaxer> you have timeout use case here?

11:10 <beneroth> I like to call the same function multiple times in parallel, using (later)

11:10 <Regenaxer> ok

11:11 <beneroth> but the function might legitimately run into an error

11:11 <Regenaxer> Needs care not to start too many processes

11:11 <beneroth> if so, I like to detect this in the parent

11:11 <beneroth> T

11:11 <beneroth> right

11:11 <Regenaxer> you can send an error token back

11:11 <beneroth> yeah right, I forgot it for now

11:12 <beneroth> using normal recursion instead, I can still parallelize later (haha) if needed

11:13 <beneroth> but then obviously better with a fixed number of worker kids instead of later

11:13 <Regenaxer> not to exeed the max?

11:13 <Regenaxer> @misc/stress.l does something like that

11:14 <Regenaxer> 40 children

11:14 <Regenaxer> using plain (fork)

11:15 <beneroth> yeah like this :-)

11:15 <Regenaxer> Not perfect for many processes

11:15 <beneroth> T

11:15 <Regenaxer> due to the manual checks

11:15 <beneroth> for many simple things, (later) is surely good enough

11:15 <Regenaxer> yeah, easiest

11:16 <beneroth> and the more extensive approach on the other side of @misc/stress.l would be a database with job entries

11:16 <Regenaxer> right

11:16 <beneroth> (this approach I did before, mainly for resilience)

11:16 <Regenaxer> that is more general and flexible

11:16 <beneroth> aye, but a bit heavy for smaller stuff

11:16 <Regenaxer> T

11:17 <beneroth> :-)

13:36 <tankf33der> https://delta.chat/en/2020-05-01-roskamnadzor

13:38 <beneroth> nice

13:40 <Regenaxer> hehe, yeah

14:07 <beneroth> Regenaxer, I like to do a non-destructive (redef), meaning I have an existing function 'foo which is recursive (it calls foo), and I like to make a second variant 'bar which decorates 'foo similar to how (daemon) works, but I want to conserve the original 'foo, so I can call both 'foo and 'bar

14:07 <beneroth> any ideas? :D

14:08 <Regenaxer> Moment, tel :)

14:08 <beneroth> okay :)

14:21 <Regenaxer> ok, done

14:22 <Regenaxer> Hmm, just cons something with the value of 'foo' and pass to 'def'?

14:23 <Regenaxer> (def 'bar (... (cons ... foo ...)))

14:27 <beneroth> that is not replacing the recursive call to 'foo within 'foo, is it?

14:50 <Regenaxer> It depends

14:51 <Regenaxer> I think you must use recur/recurse

15:00 <Regenaxer> in 'foo'

15:01 <beneroth> yeah that would make it easier

15:01 <beneroth> T, that would be a correct/elegant solution

20:05 <tankf33der> picolisp is a trap. run until its too late.

20:56 <beneroth> hehe

20:56 <beneroth> too late for what?

22:45 <DKordic> ##lisp

22:45 <DKordic> [facepalm]