[00:04] you'd have to modify https://github.com/ugexe/zef/blob/3edbbcf200e593f0f2e17f28f7c453b80d76752a/lib/Zef/Service/Shell/git.rakumod#L173 this little bit to see what the output from git it (alas the shell stuff doesn't have a way to communicate back generally yet) and then run [00:04] raku -I. -e 'use Zef::Service::Shell::git; Zef::Service::Shell::git.new.fetch(q|git@github.com:pierre-vigier/Perl6-Data-MessagePack.git|, "./bar@HEAD".IO);' [00:09] *** reportable6 left [00:15] Installed it by hand for now, kind of got my hands full on the other issue [00:15] *** evalable6 joined [00:16] *** linkable6 joined [00:16] *** nativecallable6 joined [00:16] Thread 1 is definitely hanging in Semaphore.acquire [00:16] Backtrace doesn't work on half of the threads though [00:27] *** djerius left [00:27] *** dextercd left [00:30] *** djerius joined [00:30] I'm beginning to see what's happening here [00:32] *** colemanx joined [00:33] https://pastebin.com/FxQeTWg3 [00:35] I this means it will hang if you emit while it's replaying [00:40] Though there's still a piece I'm missing [00:49] I'm pretty sure that piece is react/whenever related, so probably one of the locks in ThreadPoolScheduler [00:55] well, `react whenever` uses .act on a supply if I'm not mistaken [00:56] m: sub n { state $n = now; say sprintf("%s%s%.1f", $*THREAD, $^t, (now - $n)) }; my $s = Supplier::Preserving.new; start { for ^10 { n("e"); $s.emit(Any); sleep .1; }; $s.done }; sleep .3; react whenever $s.Supply { n("r"); sleep .1 } [00:56] rakudo-moar 1aa05bec0: OUTPUT: «Thread<4>(GeneralWorker)e0.0␤Thread<4>(GeneralWorker)e0.1␤Thread<4>(GeneralWorker)e0.2␤Thread<1>(Initial thread)r0.3␤Thread<4>(GeneralWorker)e0.3␤Thread<1>(Initial thread)r0.4␤Thread<1>(Initial thread)r0.5␤Thread<4>(GeneralWorker)r0.6␤…» [00:58] m: sub n { state $n = now; say sprintf("%s %s%.1f", $*THREAD.id, $^t, (now - $n)) }; my $s = Supplier::Preserving.new; start { for ^10 { n("e"); $s.emit(Any); sleep .1; }; $s.done }; sleep .3; react whenever $s.Supply { n("r"); sleep .1 } [00:58] rakudo-moar 1aa05bec0: OUTPUT: «4 e0.0␤4 e0.1␤4 e0.2␤1 r0.3␤4 e0.3␤1 r0.4␤1 r0.5␤4 r0.6␤4 e0.8␤4 r0.8␤4 e1.0␤4 r1.0␤4 e1.2␤4 r1.2␤4 e1.4␤4 r1.4␤4 e1.6␤4 r1.6␤4 e1.8␤4 r1.8␤» [00:59] so no new value will be emitted until all the values were consumed [01:03] I don't see whether docs anything about this blocking behaviour though [01:09] Well, deadlocks are never intentional 😉 [01:10] *** reportable6 joined [01:11] Unless you're playing the game Rush Hour [01:11] Well, I don't mean the deadlock, but .emit actually running the receiving block on its thread [01:14] *** lizmat_ left [01:14] *** lizmat joined [01:16] *** releasable6 joined [01:18] *** Geth joined [01:19] once you know that, it's enormously trivial to make a deadlock: [01:19] my $s = Supplier::Preserving.new; start { $s.emit(1); }; react whenever $s.Supply { $s.emit(2); } [01:19] you don't even need that start, just: my $s = Supplier::Preserving.new; $s.emit(1); react whenever $s.Supply { $s.emit(2); } [01:22] *** RakuIRCLogger left [01:23] *** RakuIRCLogger joined [01:23] Eh, nevermind, it's not a deadlock [01:29] *** SqrtNegInf joined [01:29] m: my $m = Promise.new; await $m [01:30] rakudo-moar 1aa05bec0: OUTPUT: «(timeout)» [01:30] Of course, but I was on about blocking `emit` [01:30] m: await $_ with Promise.new # even shorter [01:31] my $s = Supplier::Preserving.new; start { for ^2 { $s.emit($_); sleep .2; say "emit"; }; }; react whenever $s.Supply { $s.emit($_ + 1); } [01:31] rakudo-moar 1aa05bec0: OUTPUT: «(timeout)» [01:31] supply would be going infinitely and the thread would never emit second value [01:32] m: my $s = Supplier::Preserving.new; start { for ^2 { $s.emit($_); sleep .2; say "emit"; }; }; react whenever start $s.Supply { $s.emit($_); } [01:32] rakudo-moar 1aa05bec0: ( no output ) [01:32] m: my $s = Supplier::Preserving.new; start { for ^2 { $s.emit($_); sleep .2; say "emit"; }; }; react whenever $s.Supply { $s.emit($_); } [01:32] rakudo-moar 1aa05bec0: OUTPUT: «(timeout)emit␤» [01:33] m: my $s = Supplier::Preserving.new; start { for ^2 { $s.emit($_); sleep .2; say "emit"; }; }; react whenever $s.Supply { .say; $s.emit($_ + 1) if $_ < 5; } [01:33] even more puzzling that this never completes [01:33] rakudo-moar 1aa05bec0: OUTPUT: «(timeout)0␤» [01:34] i'd expect (0 1 2 3 4 5 emit 1 2 3 4 5 emit) [01:34] m: my $s = Supplier::Preserving.new; start { for ^2 { $s.emit($_); sleep .2; say "emit"; }; $s.done; }; react whenever $s.Supply { .say; $s.emit($_ + 1) if $_ < 5; } [01:34] rakudo-moar 1aa05bec0: OUTPUT: «0␤1␤2␤3␤4␤5␤emit␤1␤2␤3␤4␤5␤emit␤» [01:34] …again nevermind [02:12] *** SqrtNegInf left [02:15] *** unicodable6 joined [03:07] *** colemanx left [04:07] *** evalable6 left [04:07] *** linkable6 left [04:08] *** evalable6 joined [04:50] *** Sgeo left [04:58] *** Darkcoal joined [05:02] *** Sgeo joined [05:54] *** pierrot left [05:55] *** pierrot joined [06:09] *** reportable6 left [06:11] *** reportable6 joined [07:11] *** committable6 left [07:11] *** shareable6 left [07:11] *** squashable6 left [07:11] *** nativecallable6 left [07:11] *** sourceable6 left [07:11] *** bloatable6 left [07:11] *** reportable6 left [07:11] *** unicodable6 left [07:11] *** evalable6 left [07:11] *** tellable6 left [07:11] *** coverable6 left [07:11] *** notable6 left [07:11] *** quotable6 left [07:11] *** releasable6 left [07:11] *** statisfiable6 left [07:11] *** benchable6 left [07:11] *** bisectable6 left [07:11] *** greppable6 left [07:11] *** squashable6 joined [07:11] *** clarjon1 joined [07:11] *** quotable6 joined [07:11] *** nativecallable6 joined [07:12] *** shareable6 joined [07:12] *** notable6 joined [07:12] *** reportable6 joined [07:12] *** statisfiable6 joined [07:12] *** bloatable6 joined [07:13] *** sourceable6 joined [07:13] *** tellable6 joined [07:13] *** committable6 joined [07:14] *** evalable6 joined [07:14] *** greppable6 joined [08:10] *** linkable6 joined [08:12] *** unicodable6 joined [08:13] *** bisectable6 joined [08:35] *** jjido joined [08:50] *** Garbanzo__ left [08:55] *** jjido left [09:01] *** lockywolf left [09:09] *** frost joined [09:09] *** frost left [09:09] *** frost joined [09:13] *** releasable6 joined [10:13] *** linkable6 left [10:13] *** evalable6 left [10:13] *** jjido joined [10:14] *** linkable6 joined [10:15] *** frost left [10:16] *** evalable6 joined [10:29] *** jjido left [10:34] *** stoned75 left [10:45] *** jjido joined [10:51] *** abraxxa-home joined [11:12] *** benchable6 joined [11:13] *** coverable6 joined [11:20] *** Sgeo left [11:25] <077AAD8E0> hi, just checking my nick [11:25] <077AAD8E0> dang! [11:26] *** sivoais left [11:28] *** suman joined [11:30] This is in python print("A = {:.2%}".format(1/3)) outputs A = 33.33% [11:30] Can it be similarly done in raku? [11:32] m: printf "%.2f\n", 1/3 [11:32] rakudo-moar 1aa05bec0: OUTPUT: «0.33␤» [11:32] <077AAD8E0> hay [11:32] % thing is cute, you would have to multiply by 100 yourself [11:37] *** sivoais joined [11:54] *** Xliff_ left [11:58] moon-child Python seems to do it without multiplying by 100 [11:59] yes. That is not something you can do in raku, as far as I know [12:07] *** reportable6 left [12:11] *** suman left [12:33] <077AAD8E0> but if you want that capability, you can file an issue and lobby for your case [12:39] *** perlbot left [12:39] *** simcop2387 left [13:15] *** jjido left [13:28] *** perlbot joined [13:30] *** simcop2387 joined [13:30] *** thundergnat joined [13:31] m: sub postfix:<%> { ($^p * 100).fmt: "%.2f%%" }; say (1/3)% [13:31] rakudo-moar 1aa05bec0: OUTPUT: «33.33%␤» [13:31] :-) [13:58] *** jjido joined [14:10] *** reportable6 joined [14:15] *** jjido left [14:17] *** jjido joined [14:21] *** jjido left [14:37] *** abraxxa-home left [15:37] *** linkable6 left [15:37] *** evalable6 left [15:38] *** linkable6 joined [15:40] *** evalable6 joined [15:46] <077AAD8E0> well there you go, the power of raku coupled with saput it in a module and publish it [15:47] <077AAD8E0> *coupled with smart users [15:50] *** jjido joined [16:50] *** linkable6 left [16:50] *** evalable6 left [16:53] *** linkable6 joined [17:15] *** jjido left [17:34] *** jjido joined [17:50] *** lichtkind joined [17:51] *** evalable6 joined [18:07] *** reportable6 left [18:13] *** Garbanzo__ joined [19:07] *** abraxxa-home joined [19:09] *** reportable6 joined [19:12] *** Sgeo joined [19:17] *** Manifest0 left [19:29] *** [Coke] left [19:32] *** [Coke] joined [19:34] *** dogbert11 joined [19:36] *** dogbert17 left [19:38] *** dogbert11 left [19:42] *** Xliff joined [19:43] *** Od1n1 left [19:46] *** dogbert11 joined [19:50] *** dogbert17 joined [19:51] *** dogbert17 left [19:51] *** dogbert17 joined [19:53] *** dogbert11 left [20:00] *** Darkcoal left [20:14] *** Manifest0 joined [20:19] *** lichtkind left [20:38] what is the go to web framework on raku ? [20:41] <[Coke]> https://cro.services/ [20:49] I couldn't follow fosdem [20:50] how went the raku talks? [21:03] *** colemanx joined [21:07] *** dogbert11 joined [21:10] *** dogbert17 left [21:37] *** jjido left [21:39] *** dogbert11 left [21:39] *** dogbert11 joined [22:13] weekly: https://gist.github.com/Xliff/9a93ab12c32aceb67c195eab49c47f2d [22:13] Xliff, Noted! (weekly) [22:14] [Coke]: how crazy you wanna go with the copyright stuff? [22:15] there seems to be a bunch more than just s/2021/2022/ in a bunch of repos [22:22] *** dorkdoggler joined [22:31] raku has good support for unicode and even some logic/math symbols are there any libraries/modules that do SAT to 3MAP  "solving" so you could make a machine that works directly with statement/clause like A∨B∨∼C instead of having to parse encode everything? I'm looking at this python library and exercise: [22:31] https://sahandsaba.com/understanding-sat-by-implementing-a-simple-sat-solver-in-python.html and wondering if any perlistas or rakistas(? rakuites? rakuians?) have worked on modules/libraries/grammars in the area. Where do I search raku modules? [22:33] I found https://github.com/taboege/raku-SAT-Solver-MiniSAT [22:34] some peeps like "rakoon". im not a fan. [22:36] cool ... I thought maybe there were more raku modules I might have missed somewhere. I guess I'm used to CPAN (with decades of uploads :-D) After a few weeks I conclude that raku seems to be a simpler to use language "plain" ... with more built in so less modules needed (and having had less time to build them). [22:37] i think that's a pretty accurate assessment [22:37] perhaps. raku is younger. cpan is older:) [22:38] amusingly there are raku modules ar cpan so its not so clear cut:) [22:38] *at/on [22:40] *** oodani left [22:40] MasterDuke plus OK I am so impressed that I think I must be making a mistake ... but NativeCall ... WTF???! We get to use every decently written C library in the world out of the box?!??! [22:41] *** oodani joined [22:42] yes(-ish, i think, i don't really use NativeCall so am not the best person to ask) [22:43] MasterDuke yeah I used it with a couple of C libraries and am not an expert. But it made me think raku has already take over the world and no one noticed [22:48] I don't know if it's easier or faster than FFI::Platypus (perl5) but only because FFI::Platypus is not built-in and doesn't get as much use (usually cuz there's 12 perl modules that do the thing some c library can do). [22:54] i know Xliff is a big nativecall user, he might have some insight [23:02] *** squashable6 left [23:03] dorkdoggler: Not quite out of the box. You have to tell raku how to call the routines. [23:04] dorkdoggler: not "out of the box" as said earlier, but there is https://github.com/Skarsnik/gptrixie [23:04] Something like this: https://github.com/Xliff/p6-GLib/blob/master/lib/GLib/Raw/Array.pm6 [23:04] however I didn't use the tool much because it's very to write C mappings [23:04] s/very/very easy/ [23:05] *** squashable6 joined [23:05] Yes. gptrixie is very complex. I have a tool that will take most GLib-based .h files and covert them into Raku [23:16] *** abraxxa-home left [23:17] * leont now also has binds working in his async postgres client 😄 [23:25] leont++ [23:26] dorkdoggler: I think most languages can use c libraries [23:35] moon-child: But as you are aware, most languages require more work than Raku. [23:37] `use` comes in different forms, not many languages can just do this ootb [23:37] m: use NativeCall; sub free(Pointer) is native { * }; sub malloc(int32, –> Pointer) is native { * }; free(malloc(42))' [23:37] rakudo-moar fefbc725f: OUTPUT: «===SORRY!=== Error while compiling ␤Malformed parameter␤at :1␤------> ter) is native { * }; sub malloc(int32, ⏏–> Pointer) is native { * }; free(malloc␤» [23:38] m: use NativeCall; sub free(Pointer) is native { * }; sub malloc(int32 –> Pointer) is native { * }; free(malloc(42))' [23:38] rakudo-moar fefbc725f: OUTPUT: «===SORRY!=== Error while compiling ␤Malformed parameter␤at :1␤------> inter) is native { * }; sub malloc(int32⏏ –> Pointer) is native { * }; free(mallo␤ expecting any of:␤ constraint␤ formal para…» [23:39] uh, *nervous chuckle* [23:39] m: use NativeCall; sub free(Pointer) is native { * }; sub malloc(int32) returns Pointer is native { * }; free(malloc(42)) [23:39] rakudo-moar fefbc725f: ( no output ) [23:50] *** thundergnat left