[00:07] *** reportable6 left [00:09] *** reportable6 joined [00:56] . [01:05] *** KvL left [01:06] *** KvL joined [01:11] Is there a blin run for 2022.06? https://github.com/rakudo/rakudo/issues?q=is%3Aissue+blin [01:56] *** ocomporto joined [02:34] *** eseyman_ joined [02:35] *** eseyman left [02:35] *** eseyman_ is now known as eseyman [02:57] *** jjido left [02:59] *** frost joined [03:59] *** greppable6 left [03:59] *** linkable6 left [03:59] *** shareable6 left [03:59] *** nativecallable6 left [03:59] *** reportable6 left [03:59] *** committable6 left [03:59] *** quotable6 left [03:59] *** unicodable6 left [03:59] *** benchable6 left [03:59] *** notable6 left [03:59] *** coverable6 left [03:59] *** releasable6 left [03:59] *** statisfiable6 left [03:59] *** tellable6 left [03:59] *** bisectable6 left [03:59] *** evalable6 left [03:59] *** sourceable6 left [03:59] *** bloatable6 left [04:00] *** tellable6 joined [04:00] *** coverable6 joined [04:00] *** bloatable6 joined [04:00] *** nativecallable6 joined [04:00] *** reportable6 joined [04:00] *** sourceable6 joined [04:01] *** evalable6 joined [04:01] *** shareable6 joined [04:01] *** quotable6 joined [04:01] *** linkable6 joined [04:01] *** bisectable6 joined [04:01] *** notable6 joined [04:01] *** benchable6 joined [04:01] *** unicodable6 joined [04:01] *** greppable6 joined [04:02] *** committable6 joined [04:02] *** releasable6 joined [04:02] *** statisfiable6 joined [04:36] *** Kaiepi left [05:36] *** shareable6 left [05:36] *** evalable6 left [05:36] *** tellable6 left [05:36] *** greppable6 left [05:36] *** unicodable6 left [05:36] *** notable6 left [05:36] *** linkable6 left [05:36] *** committable6 left [05:36] *** statisfiable6 left [05:36] *** sourceable6 left [05:36] *** bisectable6 left [05:36] *** benchable6 left [05:36] *** coverable6 left [05:36] *** bloatable6 left [05:36] *** releasable6 left [05:36] *** reportable6 left [05:36] *** nativecallable6 left [05:36] *** quotable6 left [05:36] *** reportable6 joined [05:37] *** nativecallable6 joined [05:37] *** shareable6 joined [05:37] *** quotable6 joined [05:37] *** tellable6 joined [05:37] *** benchable6 joined [05:37] *** bloatable6 joined [05:38] *** statisfiable6 joined [05:38] *** greppable6 joined [05:38] *** bisectable6 joined [05:38] *** releasable6 joined [05:38] *** coverable6 joined [05:38] *** linkable6 joined [05:38] *** evalable6 joined [05:38] *** unicodable6 joined [05:39] *** sourceable6 joined [05:39] *** committable6 joined [05:39] *** notable6 joined [06:06] *** reportable6 left [06:07] *** reportable6 joined [06:11] *** abraxxa joined [06:17] *** abraxxa left [06:18] *** abraxxa joined [06:40] *** Sgeo left [07:32] *** Kaiepi joined [07:42] *** jjido joined [07:51] *** Ekho left [07:54] *** Ekho joined [07:55] *** lichtkind_ joined [08:15] *** jjido left [08:18] *** linkable6 left [08:20] *** linkable6 joined [08:39] *** MikeyHoef left [09:39] *** nativecallable6 left [09:39] *** notable6 left [09:39] *** tellable6 left [09:39] *** releasable6 left [09:39] *** benchable6 left [09:39] *** linkable6 left [09:39] *** unicodable6 left [09:39] *** reportable6 left [09:39] *** quotable6 left [09:39] *** bisectable6 left [09:39] *** committable6 left [09:39] *** sourceable6 left [09:39] *** shareable6 left [09:39] *** evalable6 left [09:39] *** bloatable6 left [09:39] *** coverable6 left [09:39] *** statisfiable6 left [09:39] *** greppable6 left [09:39] *** coverable6 joined [09:39] *** sourceable6 joined [09:40] *** nativecallable6 joined [09:40] *** quotable6 joined [09:40] *** linkable6 joined [09:40] *** committable6 joined [09:40] *** evalable6 joined [09:40] *** greppable6 joined [09:41] *** statisfiable6 joined [09:41] *** reportable6 joined [09:41] *** unicodable6 joined [09:42] *** benchable6 joined [09:42] *** shareable6 joined [09:42] *** bloatable6 joined [09:42] *** bisectable6 joined [09:42] *** releasable6 joined [09:42] *** notable6 joined [09:42] *** tellable6 joined [09:47] why is "The use of hash variables in regexes is reserved" and what does this even mean? [09:48] Nemokosch: reference ? [09:48] lizmat, I'll pass your message to Nemokosch [09:50] $ variables just interpolate their contents, @ variables interpolate as alternations, % variables don't have a function yet [09:51] reference: reality [09:51] ===SORRY!=== [09:51] The use of hash variables in regexes is reserved [09:51] at /home/ASTRON-INF/pm7342/raku_helpers/./diffblame.raku:26 [09:51] ------> when /^ 'Csak ebben: ' (%base-path⏏|%base-path) (.*?) ': ' (.*) [09:51] what does "alternations" mean? [09:51] also, I think this is kind of like a sabotage [09:52] no black magic needed, I just wanted the content [09:53] m: my @foo = ; say 'one' ~~ /@foo/ # equivalent to / one | two | three / [09:53] rakudo-moar bb9447237: OUTPUT: «「one」␤» [09:53] so if I do @%base-path [09:53] it will do exactly what I actually need? xD [09:54] you might want @(%base-path.keys) or something [09:54] since @%base-path will be a list of pairs [09:55] values, rather [09:55] but yes [09:55] let's see... [09:59] well at least it doesn't error, can't check it yet [10:00] you know, these are kind of show-stoppers in my opinion [10:01] Raku is "like a jungle sometimes", its mental load scales uncomparably worse than Python [10:01] in Python, regexes are just strings. This may not be elegant but it's ridiculously powerful once you go beyond trivial in any "deviant" way [10:01] I'm still yet to find this sort of safety in Raku [10:01] that you can just safely use what you know perfectly [10:01] well, in Raku, regexes are just another way to write code [10:02] how do I generate it, then? [10:02] I can't always hardcode it [10:02] well, before RakuAST, using EVAL I'm afraid [10:03] afaik, RakuAST already has most, if not all, API in place to generate regular expressions [10:03] nine? ^^ [10:03] the API doesn't have to be a raw string [10:03] but there is legitimate need for some API [10:03] RakuAST... it's like the land of promise [10:03] 😂 [10:03] well, yes, it is in a way... [10:04] a promise that is getting closer... [10:07] like I am getting closer to a working script [10:07] 😛 [10:09] and eventually, I can just "cast" everything to $, for values, this is feasible [10:09] by the way [10:09] say you have a dict [10:10] is there a way to obtain values with containers? [10:11] other than using them LHS in an assignment, of course [10:11] for example, iterating over the values as containers [10:20] okay... is there anything I should know about dynamic variables in react blocks?.... [10:22] https://github.com/rakudo/rakudo/issues/4654 might have some relevant info [10:22] .values on a Hash returns containers [10:23] m: my %h = :42a, :666b; dd %h; $_++ for %h.values; dd %h [10:23] rakudo-moar bb9447237: OUTPUT: «Hash %h = {:a(42), :b(666)}␤Hash %h = {:a(43), :b(667)}␤» [10:23] m: my %h = :42a, :666b; dd %h; $_++ for %h; dd %h # also slices [10:23] rakudo-moar bb9447237: OUTPUT: «Hash %h = {:a(42), :b(666)}␤Hash %h = {:a(43), :b(667)}␤» [10:26] lizmat: I see, that's not bad [10:26] BTW, same for BagHashes / MixHashes [10:26] m: my BagHash %h = :42a, :666b; dd %h; $_++ for %h; dd %h [10:26] rakudo-moar bb9447237: OUTPUT: «Type check failed in assignment to %h; expected BagHash but got Int (42)␤ in block at line 1␤␤» [10:26] ooh [10:26] what about something that retrieves the key as well, either as elements one after the other or as pairs? [10:26] m: my BagHash %h = :42a, :666b; dd %h; $_++ for %h.values; dd %h [10:27] rakudo-moar bb9447237: OUTPUT: «Type check failed in assignment to %h; expected BagHash but got Int (42)␤ in block at line 1␤␤» [10:27] m: my BagHash %h = (:42a, :666b); dd %h; $_++ for %h.values; dd %h [10:27] rakudo-moar bb9447237: OUTPUT: «Type check failed in assignment to %h; expected BagHash but got Int (42)␤ in block at line 1␤␤» [10:27] hmmm... /me makes mental note :-) [10:28] MasterDuke: thank you; so long story short, they are pretty much useless [10:28] since stdout needs to be tapped before start [10:28] basically, the processing code needs to be before start [10:28] well I can live without them, it's just... at this point, I feel I need a safe subset of Raku [10:30] and I'm afraid the safe subset of Raku wouldn't be much more attractive than Python 😅 [10:35] m: my %h is BagHash = :42a, :666b; dd %h; $_++ for %h.values; dd %h [10:35] rakudo-moar bb9447237: OUTPUT: «("b"=>666,"a"=>42).BagHash␤("b"=>667,"a"=>43).BagHash␤» [10:38] don't take me wrong, though [10:38] I will be insanely happy once this works as intended [10:38] but at the same time, this is just a helper script, basically I have this day to see if it's of any use [10:39] SmokeMachine++ # me clearly not awake enough yet :-) [10:40] m: my %h is BagHash = :42a, :666b; dd %h; for %h.kv -> $key, $value is rw { $value += ord($key) }; dd %h # Nemokosch [10:40] rakudo-moar bb9447237: OUTPUT: «("a"=>42,"b"=>666).BagHash␤("a"=>139,"b"=>764).BagHash␤» [10:41] Nemokosch: what's pretty useless? [10:41] SmokeMachine, I'll pass your message to Nemokosch [10:41] *** RakuIRCLogger left [10:41] *** Geth__ joined [10:41] *** lizmat_ joined [10:42] *** Geth left [10:43] *** lizmat left [10:48] m: my $PROCESS::BLA = 42; sub say-ble { say $*BLE }; react whenever Supply.from-list: -> $vogal { say $*BLA; my $*BLE = $vogal; say-ble } # Nemokosch: about react block and dyn var [10:48] rakudo-moar bb9447237: OUTPUT: «42␤a␤42␤e␤42␤i␤42␤o␤42␤u␤» [10:49] so rw works [10:49] I think I messed something up with the destructuring [10:49] oh no, the markdown again... [10:49] so we have $*BLE [10:49] and $*BLA maybe? [10:50] yes, $*BLA and $*BLE [10:51] I wonder if image attachments are traversed... [10:52] m: https://gist.github.com/FCO/9769e89ab94f10eb3019be7add637746 [10:52] rakudo-moar bb9447237: OUTPUT: «42␤a␤42␤e␤42␤i␤42␤o␤42␤u␤» [10:52] *** Nemokosch joined [10:52] okay let tell hit [10:52] 2022-06-07T10:07:31Z #raku Nemokosch: what do you mean about numeric context? [10:52] Nemokosch#9980: Maybe this ☝️ would help? [10:52] 2022-06-09T09:48:54Z #raku Nemokosch: reference ? [10:52] 2022-06-09T10:41:09Z #raku Nemokosch: what's pretty useless? [10:53] so the barrier is at the react block? [10:53] *** Nemokosch left [10:53] *** lizmat_ is now known as lizmat [10:54] so what I understand: as long as the dynvar is purely inside the react block, things are fine [10:54] m: https://gist.github.com/FCO/9769e89ab94f10eb3019be7add637746 [10:54] rakudo-moar bb9447237: OUTPUT: «42␤a␤42␤e␤42␤i␤42␤o␤42␤u␤» [10:56] m: https://gist.github.com/FCO/9769e89ab94f10eb3019be7add637746 [10:56] rakudo-moar bb9447237: OUTPUT: «0␤a␤1␤e␤2␤i␤3␤o␤4␤u␤» [10:57] Nemokosch: ☝️ [10:57] SmokeMachine, I'll pass your message to Nemokosch [11:01] something feels broken... [11:01] too many messages [11:01] I was changing the code and posting again... sorry for flooding... [11:26] I just realized Z can be illustrated with Harder better faster stronger [11:28] SmokeMachine: gotcha, and I think I understand [11:30] *** jjido joined [11:40] *** jjido left [11:55] *** jgaz joined [12:07] *** reportable6 left [12:10] *** reportable6 joined [12:37] i could use some help with concurrency ... I would like to do a pattern like this: main (p1) defines a sub(), then forks a new process (p2), p2 calls sub, p1 captures stdout of p2, p2 ends [12:37] (so the fork has the process context of p1) [12:39] I couldn't figure out how to do this with Async::Process seems like this is for running an external program [12:43] I have RTFMd about .fork my $promise = Promise.start( { my $i = 0; for 1 .. 10 { $i += $_ }; $i} [12:43] ); [12:44] say $promise.result; oops [12:44] I have RTFMd about .fork ... https://docs.raku.org/language/5to6-perlfunc#fork [12:44] there has been an nqp::fork added since that doc entry was written [12:46] MasterDuke: thanks ... I try to live in raku land rather than NQP ... guess that this has not yet surfaced to the raku API? [12:47] MasterDuke: (how) can I call this NQP fn from raku? [12:47] correct, nor has it been exposed in rakudo [12:47] lizmat: yes, RakuAST should have somewhat complete regex support already [12:47] m: use nqp; say nqp::add_i(1, 2) [12:47] rakudo-moar bb9447237: OUTPUT: «3␤» [12:48] nine: I wonder whether it would make sense to put that part of RakuAST already into master ? [12:48] so that people could start playing with it ? [12:53] hmmm - I vaguely recall tricks like (post fork) read own pid to decide whether I am p1/p2 then maybe some way to connect std out to std in - but too vaguely to want to go so deep [12:54] back to the drawing board [12:58] p6steve: with Raku, you generally don't want to fork [13:12] *** dogbert17 left [13:18] *** archenoth joined [13:22] thats putting it lightly [13:25] *** Sgeo joined [13:34] *** lichtkind__ joined [13:36] *** lichtkind_ left [13:37] yes, that's definitely out - don't suppose that there's a way to pipe stdout into a variable in the same process? [13:41] sure, change $*OUT :-) [13:42] p6steve: see e.g. https://raku.land/zef:lizmat/silently [13:43] specifically https://github.com/lizmat/silently/blob/main/lib/silently.rakumod#L7 the Capturer class [13:47] lizmat: that's the ticket! perfect ... you are a star! [14:06] *** eseyman left [14:06] *** eseyman joined [14:07] alas silently redirects stdout in my script ... but the stdout I want comes from nativecall and a Rust lib.so ;-( [14:08] guess I am just going to have to make a tempfile - hohum [14:33] *** frost left [14:46] *** xinming left [14:48] *** jjido joined [14:56] *** discord-raku-bot left [14:56] *** discord-raku-bot joined [15:08] *** xinming joined [15:12] <[Coke]> Right, the silent trick works on the raku handle, not the underlying one [15:12] <[Coke]> s/underlying/system/ [15:12] *** Altreus left [15:12] <[Coke]> p6steve: you could consider something like run with :out... [15:13] <[Coke]> oh, you're using like rust inline or something? [15:13] * [Coke] catches up [15:14] *** discord-raku-bot left [15:14] *** Altreus joined [15:14] *** discord-raku-bot joined [15:16] *** melezhik joined [15:17] Hi! [15:18] *** jjido left [15:18] I am thinking about spinning  up a service that allow people to run integration tests against their docker images, similar to SparkyCI but with focus on docker [15:19] so a user could deploy their docker images into temporary docker instance and run https requests against it [15:19] or run some ssh commands within docker instance to check internal structure [15:20] could be useful for Raku devs building services on Raku [15:20] just testing a water here if this is something people might find useful? [15:21] I am thinking about testing raku.land or whatever Raku related services that are distributes as docker images [15:21] again because I am going to build and own this service it's possible to bake as much Raku integration as possible into it ... [15:22] ant thoughts? I'd appreciate for a feedback  ... [15:33] *** vrurg left [15:37] <[Coke]> m: my @out; for (^1000).grep(*.is-prime).join.comb { last if @out.elems == 10; next if @out.grep($_); @out.push: $_ } put @out; [15:37] rakudo-moar bb9447237: OUTPUT: «===SORRY!=== Error while compiling ␤Strange text after block (missing semicolon or comma?)␤at :1␤------> ; next if @out.grep($_); @out.push: $_ }⏏ put @out;␤» [15:37] <[Coke]> m: my @out; for (^1000).grep(*.is-prime).join.comb { last if @out.elems == 10; next if @out.grep($_); @out.push: $_ }; put @out; [15:37] rakudo-moar bb9447237: OUTPUT: «2 3 5 7 1 9 4 6 8 0␤» [15:38] <[Coke]> (order of digits as they appear in prime numbers, wh [15:38] <[Coke]> ee) [15:39] <[Coke]> Surely that can be golfed. [15:53] *** lichtkind__ left [15:53] *** lichtkind joined [15:55] *** vrurg joined [15:57] *** kaskal- joined [15:57] *** melezhik left [15:57] *** kaskal left [16:09] probably want to get rid of the .join since then the iteration through ^1000 will have o complete [16:14] m: (0..Inf).grep(*.is-prime).join.map({ say $_ }) [16:14] rakudo-moar bb9447237: OUTPUT: «...␤» [16:14] uh what [16:14] m: say (0..Inf).join [16:14] rakudo-moar bb9447237: OUTPUT: «...␤» [16:14] That doesn't seem correct [16:15] I think I'd rather have it hang indefinitely [16:29] m: (0..Inf).join.is-lazy.say; [16:29] rakudo-moar bb9447237: OUTPUT: «False␤» [16:32] m: (0..Inf).^can('join')[0].&{.file, .line}.say; [16:32] rakudo-moar bb9447237: OUTPUT: «(SETTING::src/core.c/Any.pm6 178)␤» [16:35] *** thundergnat joined [16:35] m: say (^110).grep(&is-prime)».comb.flat.unique [16:35] rakudo-moar bb9447237: OUTPUT: «(2 3 5 7 1 9 4 6 8 0)␤» [16:35] 2021-06-03T11:02:00Z #raku-dev .tell thundergnat that looks like a bug, could you make an issue for it? [16:35] 2021-06-03T12:57:00Z #raku-dev .tell thundergnat https://github.com/rakudo/rakudo/commit/89fd8a8df8 tests would be appreciated :-) [16:35] *** thundergnat left [16:35] Range.join ends up in List.join with a List made with List.from-iterator [16:37] And since (0..Inf) is lazy, we end up with a stringification for a lazy list. [16:38] Actually, we might end up with `nqp::if($infinite,'...','')` . [16:43] m: (0..Inf).join.put [16:43] rakudo-moar bb9447237: OUTPUT: «...␤» [16:48] I can't find stringification of infinite lists in Roast. [17:04] *** Kaiepi left [17:04] *** Kaiepi joined [17:05] *** Kaiepi left [17:05] *** Kaiepi joined [17:13] Coke: yep I'm making a lib.so with rust then nativecall ing it ... finally bit the bullet and doing as Nativecall callback [17:13] *** kaskal- left [17:14] *** kaskal joined [17:20] *** Sankalp left [17:21] *** Sankalp joined [17:33] Coke: I have put the recipe for Rust callbacks here https://github.com/p6steve/raku-Inline-Rust [17:37] *** kaskal left [17:37] *** kaskal joined [17:44] *** morte_ joined [17:54] *** kaskal left [18:08] *** reportable6 left [18:10] *** reportable6 joined [18:11] *** kaskal joined [18:52] *** dogbert17 joined [18:56] *** mexen left [18:59] *** monkey_ joined [19:26] *** morte_ left [19:29] *** abraxxa left [19:34] *** Kaiepi left [19:37] *** monkey_ left [20:00] *** morte_ joined [20:02] *** Kaiepi joined [20:09] just went from 1.1k to 1.2k rakoons on reddit [20:10] yup, yesterday... well actually it just got past 1150 (1154 now) [20:22] It's still progress. [20:23] *** lizmat_ joined [20:27] *** lizmat left [20:31] *** morte_ left [20:39] *** linkable6 left [20:42] *** linkable6 joined [21:04] Is %hash>>.methodcall described somewhere in the docs? [21:05] <[Coke]> https://docs.raku.org/language/operators#methodop_%C2%BB._/_methodop_%3E%3E. [21:10] I don't see anything about the behavior with hashes [21:11] The very slight mention I could find at the general hyper description: [21:11] > Hyper operators can work with hashes. The pointy direction indicates if missing keys are to be ignored in the resulting hash. The enclosed operator operates on all values that have keys in both hashes. [21:12] What does determine the popularity of reddit group? (Lilke /r/rakulang.) The quantity of the posts? The quality? Or, as in Raku's case, "just" the number of Raku-users and/or Raku-curious? [21:13] <[Coke]> was just pointing at the >>. operator. To offer an example: [21:14] <[Coke]> m: my %e = ; dd %e>>.uc; [21:14] rakudo-moar b5a82d28b: OUTPUT: «{:a("B"), :c("D")}␤» [21:14] It does seem that de facto it operates on the value [21:14] I'm already using that [21:16] I was just curious if this behavior is explicitly recorded somewhere [21:29] *** morte_ joined [21:29] *** MasterDuke left [21:34] m:1154.round(100) [21:34] <[Coke]> $ ack '%.*>>\.' # 5 files in roast, 10 hits or so [21:34] p6steve, rakudo-moar b5a82d28b: OUTPUT: «» [21:35] <[Coke]> m: dd 1154.round(100) [21:35] rakudo-moar b5a82d28b: OUTPUT: «1200␤» [21:35] <[Coke]> m: dd 1154.round(103) [21:35] rakudo-moar b5a82d28b: OUTPUT: «1133␤» [21:40] *** MasterDuke joined [21:40] *** xinming left [21:41] m: dd 'haha' [21:41] rakudo-moar b5a82d28b: OUTPUT: «"haha"␤» [21:41] *** xinming joined [21:41] haha [21:51] *** jgaz left [21:55] *** morte_ left [21:59] <@297037173541175296> >>. is an operator and those coerce by design. Since >>. will operate on List, it will coerce any LHS to that. [22:01] that doesn't explain the behavior, though. The has turns into a list of pairs, what happens then? [22:01] also, new thing [22:03] what is the difference between |(blah) and (blah).Slip? [22:04] that doesn't explain the behavior, though. The hash turns into a list of pairs, what happens then? [22:07] see: https://github.com/rakudo/rakudo/blob/master/src/core.c/List.pm6#L1605 [22:13] does this mean they should always work identically? because they don't... [22:14] again, what is the catch? 😂 [22:19] *** jjido joined [22:27] *** Kaiepi left [22:30] *** paurq left [22:52] *** lichtkind left [23:13] *** monkey_ joined [23:20] *** jgaz joined [23:32] *** jgaz left [23:32] *** monkey_ left [23:39] *** kaskal- joined [23:39] *** kaskal left [23:42] *** jjido left [23:51] huh, activity. [23:51] nice. [23:51] |(blah) and (blah).Slip work the same, sort of [23:51] m: my $s = |(1); my $s2 = (1).Slip; dd $s; dd $s2; [23:51] rakudo-moar b5a82d28b: OUTPUT: «Slip $s = $(slip(1,))␤Slip $s2 = $(slip(1,))␤» [23:52] …however [23:52] m: dd |(1); dd (1).Slip; [23:52] rakudo-moar b5a82d28b: OUTPUT: «1␤slip(1,)␤» [23:54] *** simcop2387 left [23:54] I think it only makes difference when used in context of method call [23:56] *** Kaiepi joined [23:57] *** simcop2387 joined [23:59] *** jgaz joined