[00:11] *** guifa2 joined [00:25] *** guifa2 left [00:46] *** lucasb left [02:16] *** finsternis left [03:16] *** sourceable6 left [03:16] *** statisfiable6 left [03:16] *** bloatable6 left [03:16] *** linkable6 left [03:16] *** benchable6 left [03:16] *** shareable6 left [03:16] *** quotable6 left [03:16] *** squashable6 left [03:16] *** unicodable6 left [03:16] *** greppable6 left [03:16] *** tellable6 left [03:16] *** releasable6 left [03:16] *** coverable6 left [03:16] *** nativecallable6 left [03:16] *** notable6 left [03:16] *** reportable6 left [03:16] *** bisectable6 left [03:16] *** committable6 left [03:16] *** evalable6 left [03:17] *** squashable6 joined [03:17] *** coverable6 joined [03:17] *** sourceable6 joined [03:17] *** evalable6 joined [03:18] *** notable6 joined [03:18] *** benchable6 joined [03:18] *** committable6 joined [03:18] *** linkable6 joined [03:18] *** statisfiable6 joined [03:18] *** bloatable6 joined [03:18] *** reportable6 joined [03:18] *** releasable6 joined [03:18] *** greppable6 joined [03:18] *** quotable6 joined [03:18] *** shareable6 joined [03:19] *** bisectable6 joined [03:19] *** nativecallable6 joined [03:19] *** unicodable6 joined [03:19] *** tellable6 joined [04:08] Playing around with prepending codepoints in graphemes, I came across this strange issue: [04:09] nqp: say("\x[600]a"); say("\x[600]ä"); say("\x[600]ä") [04:09] nqp-moarvm: OUTPUT: «؀a␤؀ä␤؀ä␤» [04:10] Seems like a problem with me running this on the commandline, but that last one (which use a diaeresis codepoint over a instead of a precombined character) comes out visually as "a xCC x88" [04:11] Huh, yeah, seems like a problem with using -e specifically. REPL prints it fine. [04:14] The problem doesn't need the prepending character, nqp -e 'say("ä")' is sufficient (and the problem shows up in rakudo too) [04:15] And it works fine if you try s̈ for instance; seems just character combos that NFC would end up joining into a single codepoint so far. [04:31] One more note: --target=ast shows the string argument is already corrupted, so the problem is showing up either before or during parsing. [04:33] (well, uh, that's assuming the printer outputting the QAST tree isn't the same as the one say() uses, were it to be an issue with say().) [04:37] nqp::chars("ä") returns 9, so it's definitely an issue with how the source code is being handled [06:50] *** domidumont joined [07:48] *** Altai-man_ joined [08:12] *** tbrowder__ joined [08:20] *** tbrowder left [08:20] *** tbrowder__ is now known as tbrowder [08:23] *** camelia left [08:25] *** camelia joined [08:27] *** sena_kun joined [08:29] *** Altai-man_ left [10:00] *** guifa2 joined [10:08] *** jmerelo joined [10:08] releasable6: status [10:08] jmerelo, Next release in ≈24 days and ≈8 hours. There are no known blockers. Changelog for this release was not started yet [10:08] jmerelo, Details: https://gist.github.com/a895bb9c85f87e653c9d3b6eb8c18518 [10:13] Adding a mainline_frame to MoarVM's MVMCompUnit wasn't that hard after all. Thanks to a bump in the bytecode version to 7 and retaining backwards compatibility, I dind't need a bootstrap for NQP [10:14] Now I get through NQP's compilation and nqp-m works, too. It fails in the setting compilation where it suddenly doesn't find a Blob's body block anymore and tries to execute a VMNull instead [10:24] *** guifa2 left [10:25] *** guifa2 joined [10:27] *** Altai-man_ joined [10:27] *** guifa2 left [10:29] *** sena_kun left [10:30] *** guifa2 joined [10:36] .seen cosimo [10:36] jmerelo, I saw cosimo 2018-10-08T15:04:21Z in #perl6: thanks El_Che [10:36] That's some time [11:00] *** squashable6 left [11:03] *** squashable6 joined [11:08] question, please: how can i set a variable in src/Perl6/Compiler.nqp that i can access in src/core.c/Pod.pm6? i see use of reading an hllsym in Array.pm6 but i'm not sure how to set it. [11:09] just use a dynamic variable? [11:09] all this for lack or presence of a simple newline [11:10] so i can read the existing $*keep-decl from Grammar.nqp? [11:12] hm, as simple as that, doh. i'll try that. thnx! [11:18] Actually it does run Blob's body but that throws an exception when trying to run (T.^nativesize / 8).Int [11:18] It may actually be the method_not_found_error handler that runs into the VMNull [11:23] ¦ problem-solving: JJ self-assigned Ecosystem: versioning issues https://github.com/Raku/problem-solving/issues/72 [11:23] ¦ problem-solving: JJ unassigned from jnthn Issue Ecosystem: versioning issues https://github.com/Raku/problem-solving/issues/72 [11:48] Looks like it's failing to call closures from compile time executed code (like role bodies and trait_mods) like $parent.^methods.grep({$_.yada}) [12:17] ShimmerFairy: that looks like it's using utf8-c8 somewhere [12:20] What gets me is that it's, at least so far, only precomposeable stuff, which is why I didn't for example blame my terminal emu. [12:23] i think "precomposable" is because "turning it into NFG will lose info, so utf-c8 will preserve that info for you" [12:24] i bet you can use two non-precomposable composing characters on one base and flipping the order around will give you either the c8 synthetic character or the regular form [12:24] based on what order the normalization would give them [12:28] *** sena_kun joined [12:29] *** Altai-man_ left [12:34] ¦ nqp/master: 4 commits pushed by andreoss++, (Jonathan Worthington)++ [12:34] ¦ nqp/master: a564019b10 | [jvm] Add @Override & remove boxing [12:34] ¦ nqp/master: ffe859c83c | [jvm] Add @Override [12:34] ¦ nqp/master: 8dc6af179d | [jvm] Remove boxing [12:34] ¦ nqp/master: c2f40b47a6 | Merge pull request #639 from andreoss/jvm-override [12:34] ¦ nqp/master: review: https://github.com/Raku/nqp/compare/1f308c711821...c2f40b47a6c5 [12:35] The odd thing about this VMNull error I get is that if anything there should now be less of a chance of missing a callable object as we share almost everything between inner and outer compilations (most notably frames array and fixup lists) [12:44] *** ccamel left [12:45] *** camelCaser joined [12:54] *** pamplemousse joined [12:56] *** guifa2 left [12:58] *** jmerelo left [13:00] All I knew about UTF-C8 is a vague sense that it lets you put nulls in null-terminated strings. [13:00] *** pamplemousse left [13:01] But I was thinking that there was something deciding "this could be precomposed, but it isn't, so I'm explicitly refusing", I just didn't know what would do that or why. [13:01] any invalid UTF-8 [13:02] *** guifa2 joined [13:03] I don't know if UTF-C8 is appropriate here (I was surprised by it, so I'd lean towards no right now), but at the very least I think commandline args and REPL input should be consistent, since they both involve someone typing at a terminal. [13:04] *** guifa2 left [13:13] Holy cow! I think...I've got it. By just not sharing anything with the outer compiler in compile_in_context I get through the build and finally routines created by BEGIN time EVAL make it through precompilation! [13:14] Which means one can now precompile a module that uses a module :from that is extended with a raku block which may contain attributes with accessors and methods. [13:26] And brings hope for quite a few issues about BEGIN time EVAL and constants [13:39] ShimmerFairy: i'm not sure how c8 would allow a null inside a null-terminated string, but it's generally built so that you can roundtrip any data while decoding as much of it as possible as valid UTF8 [13:41] so when you have uncomposed stuff for which a precomposed form exists it builds a synthetic that encodes to the original when encoding to utf8-c8, but encodes to a special character sequence when encoding to regular utf8 [13:41] same for completely invalid utf8 [13:43] It may not be UTF-C8, but I remember some system that let you encode a null in a usually-illegal overlong form, freeing up the literal byte value 0x00 to be a string terminator. [13:54] utf16 :D [13:58] btw, does the CPPStruct REPR only work on certain C++ classes? (Like, say, only standard layout types?) The name being "struct" makes me think so, but I don't know for sure. [14:00] i don't know what other kinds of cpp classes are [14:00] there are* [14:01] The "kinds" are really just how gnarly things get under the hood, depending on how fancy you get. [14:03] I suppose I'd be surprised if you couldn't somehow strongarm CPPStruct into supporting any C++ class, so I suppose the question is more "how much does CPPStruct know about C++ classes? How much would I have to be like a very stubborn C programmer trying to use a C++ class directly?" [14:04] mhm, i think we don't have support for explicitly setting the alignment of any given attribute, so that could be annoying i guess? [14:06] Also, it's fun thinking about how the hell you'd support templates. You'd either need a module user to have a compiler installed, or provide a supplemental library with a gazillion instantiations. [14:08] Just write a C++ compiler in Raku... :) [14:10] *** Ven_de_Thiel joined [14:10] I've thought about a C or C++ compiler in Rakudo or NQP before, but one problem (among likely many) is that those languages don't expose enough info/control over floating points. :) [14:11] *** guifa2 joined [14:13] ShimmerFairy: I know Dlang has pretty amazing support for C++ templates (https://dlang.org/spec/cpp_interface.html#cpp-templates) [14:15] And Nim also has good support (https://github.com/3dicc/Urhonimo/blob/master/modules/container/hashmap.nim is an example, though I admittedly don't know that much Nim) [14:16] The issue is that templates do not exist in compiled code. The instantiations do, but in order to provide arbitrary instantiations in Raku (via, say, parameterized roles), you'd have to do something with the source code itself. [14:16] I know [14:16] I'm just saying they probably had to face similar issues. [14:17] I notice in the D example they write code that only exists to instantiate the code, so D doesn't have to think about that issue. [14:18] Well, they do it for template functions at least. [14:19] yeah... they could also just write `template class Foo;` I think. [14:19] oh no, they do it for all templates. "Note that all instantiations used in D code must be provided by linking to C++ object code or shared libraries containing the instantiations." [14:20] welp :-( [14:21] doesn't help that every single C++ project uses a different build system or version thereof [14:21] There's nothing wrong with that solution, just would be nice if a Raku user could type my CppVector[int8] $foo; and have it just work. [14:23] That ideal solution would require a C++ compiler on the machine (which will be different kinds of painful for different people), or even worse, have Raku parse header files. [14:24] that requires implementing a C++ VM, which is pretty difficult :-) [14:24] At the very least, an ability to figure out the raw layout of a C++ class from its definition. [14:26] The good news may be that C++20 will come with honest-to-goodness modules, which will of course be able to contain templated stuff (or else nobody would bother with them), so maybe module-using code at least will work nicely. [14:27] *** Altai-man_ joined [14:29] *** sena_kun left [14:29] I don't think modules will really help [14:59] *** guifa2 left [14:59] *** guifa2 joined [15:41] *** guifa2 left [15:45] *** jmerelo joined [16:22] *** jmerelo left [16:27] *** sena_kun joined [16:29] *** Altai-man_ left [16:37] <[Tux]> Rakudo version 2020.05.1-206-g986f8ab6b - MoarVM version 2020.05-15-g644533ad1 [16:37] <[Tux]> csv-test-xs-20 0.383 - 0.385 [16:37] <[Tux]> test-t --race 0.811 - 1.152 [16:37] <[Tux]> csv-ip5xs 0.817 - 0.845 [16:37] <[Tux]> test-t 1.886 - 2.199 [16:37] <[Tux]> test 7.376 - 7.840 [16:37] <[Tux]> csv-ip5xs-20 8.138 - 8.483 [16:37] <[Tux]> test-t-20 --race 8.812 - 9.554 [16:37] <[Tux]> csv-parser 24.325 - 24.916 [16:37] <[Tux]> test-t-20 30.831 - 31.435 [16:56] *** guifa2 joined [17:21] *** patrickb joined [17:42] *** Ven_de_Thiel left [17:50] *** domidumont left [18:18] *** guifa2 left [18:24] vrurg: you have fixed issues with subs and operators from the setting not working in nested scopes at BEGIN time, haven't you? What was the fix? [18:25] nine: I'd need to look into my PRs to recall. [18:26] Looks like I've got the very same now with those precompiled raku block in Perl 5 modules. Everything works unless I access subs or operators [18:27] *** Altai-man_ joined [18:28] I think you're talking about another issue. A closure was not getting its outer set. It was a fix for MoarVM. [18:28] M#1209 [18:28] M#1209 [closed]: https://github.com/MoarVM/MoarVM/pull/1209 Fix run-away CORE context on closures [18:29] *** sena_kun left [18:29] Darn....the symptoms are exactly the same though [18:31] Well maybe I give it the wrong outer context [18:32] Most likely. [18:32] Do you see core symbols from the failure location? [18:35] How do I check? [18:36] CORE::.keys [18:37] Though I usually just iterate over outerctx and dump symbols. Let me see the whole picture. [18:37] *lets me [18:38] "greet_me".note; prints as expected but CORE::.keys.note; just throws a "Cannot invoke this object (REPR: Null; VMNull)" [18:42] note "greet me" is a better check because in this case it looks up note in lexical outers. I'm not so sure about the method call. [18:48] That gives me "Cannot invoke this object (REPR: Null; VMNull)" [18:48] it's why I switched it to the method call so I know that my code at least gets executed :) [18:50] *** patrickb left [18:51] *** rypervenche left [18:53] *** rypervenche joined [18:54] Ok, I just have 2 outer contexts. One containing $_, ::?PACKAGE, ::?CLASS, $?CLASS the other doing %?LANG, $_, ::?PACKAGE, !UNIT_MARKER, $=pod, $?PACKAGE, RakuBlock, EXPORT [18:55] Clearly CORE is missing [19:02] *** guifa2 joined [19:10] *** guifa2 left [19:28] jnthn: sometimes a hammer just is the right tool. Back when we first discussed the language version issue I also had the idea of doing the kind of multi dispatch on language version you describe. Just without the means to actually implement it :) [19:36] *** cognominal joined [19:38] *** cognominal left [19:43] *** lucasb joined [19:46] I'd say the new dispatching is rather a swiss army knife. But better. Yet, I have strong doubts about methods of the same instance behaving differently depending on the caller version. Thinking about it. [19:54] *** cognominal joined [19:56] *** Kaeipi joined [19:57] *** Kaiepi left [20:02] ¦ rakudo: coke++ created pull request #3724: Change INSTALL to markdown [20:02] ¦ rakudo: review: https://github.com/rakudo/rakudo/pull/3724 [20:15] *** patrickb joined [20:18] *** patrickb left [20:27] *** sena_kun joined [20:29] *** Altai-man_ left [21:33] nine, vrurg I'm very, very tentatively wondering about claiming upper-case adverbs on names for language-provided things (:D/:U already fit that) and making the syntax `multi method foo:LANG<6.e+>(...)`, along with allowing `foo:D` and `foo:U` to be shortcuts to the `::?CLASS:D:` eyefull often seen in signatures... [21:34] And that way it generalizes onto any name too, so if we deem we actually want different classes entirely between language versions (knowing they are type incompatible) then `class Foo:LANG<6.e+> { }` also naturally follows. [21:34] it took me a moment, but now i get it, lol [21:35] but `method blorb:D($hello) { }` wouldn't that parse $hello as just the argument to :D? [21:35] timotimo: eww, yes [21:35] enforce a space? [21:35] Hmm, OK, that's probably why we didn't do this :) [21:36] require it to be :D:(...) [21:36] even worse? :D [21:36] Dunno, it's a tad unfortunate [21:36] As I said, only very tentative :) [21:36] i'd really like a shortcut for this, yeah [21:36] Thing is that we really need to leave foo:sym alone as being a normal name component [21:36] what if we allow `_:D:` at the start of the signature [21:36] kind of to mirror :_ being "any definedness" [21:37] _:D being "the thing, but defined" [21:37] I'm not sure I could live with being to blame for (_:_:) being valid syntax :P [21:37] hm. it doesn't really say "the current class", just "anything" which isn't what it means [21:38] That too [21:39] vrurg: Anyways, there are problems that would be aided by method-level versioning by language; for example, we'd like to clear up the IO::Handle.new situation, but don't really want a whole IO::Handle definition just for that. [21:40] do any other languages have names/syntax we could borrow? i'm thinking of this/it, but i believe those all refer to the instance, not the class [21:41] Yeah, I can only think of instance-y ones [21:45] i seem to recall we have something in the "multi: no match" exception message printer for when you got an undefined, but only defineds would work? [21:45] perhaps only for arguments, not for the invocant? [21:45] m: print(Str) [21:45] rakudo-moar 986f8ab6b: OUTPUT: «Use of uninitialized value of type Str in string context.␤Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful.␤ in block at line 1␤» [21:45] m: sin(Int) [21:45] rakudo-moar 986f8ab6b: OUTPUT: «WARNINGS for :␤Useless use of "sin(Int)" in expression "sin(Int)" in sink context (line 1)␤Invocant of method 'Bridge' must be an object instance of type 'Int', not a type object of type 'Int'. Did you forget a '.new'?␤ in block at…» [21:45] pffft :) :) [21:45] m: sin(Real) [21:45] rakudo-moar 986f8ab6b: OUTPUT: «WARNINGS for :␤Useless use of "sin(Real)" in expression "sin(Real)" in sink context (line 1)␤Invocant of method 'Bridge' must be an object instance of type 'Real', not a type object of type 'Real'. Did you forget a '.new'?␤ in block m: sin(Numeric) [21:46] rakudo-moar 986f8ab6b: OUTPUT: «WARNINGS for :␤Useless use of "sin(Numeric)" in expression "sin(Numeric)" in sink context (line 1)␤No such method 'sin' for invocant of type 'Numeric'␤ in block at line 1␤␤» [21:46] does it have to be attached to the name? what about something like `returns`? e.g., `method foo ($b) belongs v6.e+ { ... }` [21:46] ah, it forwards to a method call [21:47] MasterDuke: I don't really want to introduce new special-case syntax, if we can avoid it [21:47] ah! we have that for "requires mutable arguments" [21:56] So https://stackoverflow.com/questions/62051742/whats-the-real-difference-between-a-token-and-a-rule is quite fascinating [21:56] Somehow, when it's a rule, it ends up being happy to backtrack the *, apparently [21:59] And it's the sigspace directly aftr the * that causes it [21:59] I wonder if this is an issue in NQP too, and how much performance it costs us. [22:00] It's a bit unfortunate --target=ast doesn't dump out the backtrack on a quant [22:04] would NQP_NFA_DEB be useful? [22:05] No, I suspect it's mis-construction of the AST [22:10] *** MasterDuke left [22:11] Ah, and also: the NFA isn't used at the entry to the TOP rule, so it really can't be that [22:15] dump the spesh log and try figuring out from the bytecode how it was constructed, lol [22:15] It's probably faster to improve the dumper :P [22:16] :D [22:16] when do we introduce a dumper in a more formal format and a separate viewer that gives you lots more fine-grained control? [22:17] could come with rakuast i guess :) [22:20] there's one of zof's tools that turns qast dump output into an html file that lets you collapse stuff and it's colored and disemphasizes the "other" branch of a WANT [22:20] Want* [22:27] *** Altai-man_ joined [22:29] *** sena_kun left [22:54] *** Kaiepi joined [22:55] *** Kaeipi left [23:00] *** Xliff joined [23:16] What an interesting discussion I missed here! [23:59] *** Altai-man_ left