| ugexe | m: my %h; %h<a> = 1; say %h.keys.head.WHAT | 01:58 | |
| camelia | (Str) | ||
| ugexe | why does that get to be a Str but | ||
| m: my Str $x = <1>; say $x.WHAT | |||
| camelia | (IntStr) | ||
| ugexe | that has to be an IntStr | ||
| i guess because it just coerces everything to str | 02:00 | ||
| it would be nice if `my Int $y = 0; my Str $x = $y;` could be a compile time error, but it can't because of allomorphs | |||
| which is sad because that being a compile time error is way more useful than not having to explicitly coerce env variables or main params to the expected type | 02:01 | ||
| japhb | m: my Int $y = 0; my Str $x = $y; dd $x, $y; | 02:34 | |
| camelia | Type check failed in assignment to $x; expected Str but got Int (0) in block <unit> at <tmp> line 1 |
||
| japhb | ugexe: I'm guessing you meant `my Int $y = <0>` ? | 02:35 | |
|
09:13
lizmat joined
09:47
lizmat left
|
|||
| ab5tract | I wonder if allomorphs arrived conceptually before coercions did? | 13:34 | |
| I don't think you'd develop allomorphs without being a) a successor to Perl and b) not already having coercions at hand | 13:36 | ||
| ugexe | japhb that is runtime | 13:49 | |
| having slept on it though its not allomorphs that prevent it, its just the most obvious example | 14:58 | ||
| really the type check applies to the value which isn't known at compile time usually | 14:59 | ||
| Geth | rakudo/main: 5be14389eb | (Nick Logan)++ | tools/build/raku-ast-compiler.nqp Let the RakuAST source preprocessor skip an empty comment Previously the ws token in tools/build/raku-ast-compiler.nqp needed at least one character after a # to treat it as a comment. A bare # at the end of a line matched nothing, which went unnoticed because the <?[\s#]> lookahead in front of it consumed that character instead of merely checking for it. With the regex compiler now honoring the lookahead, the code tokenizer looped on such a line without progress. This accepts a comment with nothing after the #. |
16:26 | |
| rakudo/main: c69055bdc6 | (Nick Logan)++ | src/Raku/ast/regex.rakumod RakuAST: drop marker flags from character class subtraction Previously RakuAST::Regex::Assertion::CharClass set the zerowidth and negate flags on the concat node it built for a subtracted element, and RakuAST::Regex::CharClassElement::Enumeration set negate on the concat for a negated enumeration with more than one part. The regex compiler ignored those flags on group nodes, which is also why lookarounds such ... (13 more lines) |
|||
| rakudo/main: 1a21cd5ac4 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Merge pull request #6641 from ugexe/ugexe/regex-zerowidth-groups RakuAST: drop marker flags from character class subtraction |
|||
| nqp/main: 14672f427e | (Nick Logan)++ | src/QRegex/P6Regex/Actions.nqp Decide character class subtraction by its sign Previously assertion:sym<[> treated any element whose compiled node had its negate flag set as a subtraction, so <[a] + [\S]> excluded the non-space characters instead of adding them. It also set the zerowidth and negate flags on the concat node it built, and cclass_elem set negate on its own, as markers the regex compiler does not act on there. ... (10 more lines) |
16:54 | ||
| nqp/main: bb66b142c6 | (Nick Logan)++ | 4 files Honor zerowidth and negate on regex group nodes Previously the MoarVM regex compiler only acted on the zerowidth and negate flags of leaf nodes. A lookaround over a character class that compiles to an alt or concat, such as <?[\s a]> or <![a] - [b]>, had the flags set on that group node, so its parts still consumed a character and a negated one was not inverted at all. ... (7 more lines) |
|||
|
16:54
[Coke] left
|
|||
| Geth | nqp/main: 260582462c | (Nick Logan)++ (committed using GitHub Web editor) | 5 files Merge pull request #869 from ugexe/ugexe/regex-zerowidth-groups Honor zerowidth and negate on regex group nodes |
16:54 | |
| rakudo: ugexe++ created pull request #6644: Bump NQP to honor zerowidth and negate on regex group nodes |
16:56 | ||
| rakudo/main: 490a59092f | (Nick Logan)++ (committed using GitHub Web editor) | tools/templates/NQP_REVISION Bump NQP to honor zerowidth and negate on regex group nodes (#6644) |
17:42 | ||
| nqp/main: 37a755a41b | (Nick Logan)++ | 2 files Give ignoremark character lists base character NFA edges Previously a character list compiled under :ignoremark got a charlist edge in the LTM NFA, which compares whole graphemes. When such a list sat in an alternation, for instance the one <[ a \n ]> compiles to, the NFA ruled the branch out on marked input like "a\x[300]" before the mark insensitive runtime check could run. This gives a non negated ignoremark list one base character edge per entry, which is what an ignoremark literal already gets. Negated lists keep the charlist edge, since that only ever lets more branches through. |
18:15 | ||
| nqp/main: b9b9e553ee | (Nick Logan)++ | 3 files Fold character class entries after assembling them Previously a character class folded each plain character for :ignorecase and :ignoremark before appending it to the entries, and escaped characters were appended without any folding at all. As such <[ \x[E0] ]> under :ignoremark did not match "a", and an entry that adjacent characters form under NFG, such as the "à" in <[ a \x[300] ]>, ... (9 more lines) |
|||
| nqp/main: f54a86c7d2 | (Nick Logan)++ (committed using GitHub Web editor) | 4 files Merge pull request #870 from ugexe/ugexe/regex-charclass-escapes Fix ignoremark and escape handling in character classes |
|||
| rakudo: ugexe++ created pull request #6645: Bump NQP to fix ignoremark and escape handling in character classes |
18:26 | ||
|
18:27
lizmat joined
18:51
[Coke] joined
|
|||
| Geth | rakudo/main: 3b9bf77294 | (Nick Logan)++ (committed using GitHub Web editor) | tools/templates/NQP_REVISION Bump NQP to fix ignoremark and escape handling in character classes (#6645) |
19:09 | |
| nqp/main: 4176b65f51 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Flush the position before subrule arguments and limits blocks run (#868) Previously the MoarVM regex compiler wrote the position register back to the cursor's $!pos only after it had compiled the arguments of a subrule call, and never before running a dynamic quantifier's limits block. Code that ran as part of either saw the cursor's stale $!pos: -3 from cursor creation, or the position of the last flush. In Raku ... (8 more lines) |
19:10 | ||
| rakudo: ugexe++ created pull request #6646: Bump NQP to flush the regex position before subrule arguments and limits blocks run |
19:16 | ||
| rakudo/main: 8bb460f2aa | (Nick Logan)++ (committed using GitHub Web editor) | src/Raku/ast/regex.rakumod RakuAST: Fold character class entries after assembling them (#6642) Previously a character class folded each plain character for :ignorecase and :ignoremark before appending it to the entries, and escaped characters were appended without any folding at all. As such <[ \x[E0] ]> under :ignoremark did not match "a", and an entry that adjacent characters form under NFG, such as the "à" in <[ a \x[300] ]>, ... (11 more lines) |
19:19 | ||
|
19:31
lizmat left
|
|||
| Geth | rakudo/main: 17f3157cde | (Nick Logan)++ (committed using GitHub Web editor) | tools/templates/NQP_REVISION Bump NQP to flush the regex position before subrule arguments and limits blocks run (#6646) |
20:04 | |
| rakudo/main: 63811d17ce | (Nick Logan)++ (committed using GitHub Web editor) | 3 files Take apart only an index or coercion on the right of but and does (#6643) Previously both frontends split any call op on the right of but or does whose first argument had a compile time value into the role and a named value argument, so `42 but "a" ~ $s` and `42 but f(Role, "x")` went to the operator as a role plus value instead of as the result of the call. The RakuAST frontend had escaped that for operator calls, ... (5 more lines) |
20:05 | ||
| rakudo/main: a63417ba40 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Settle a channel's closed promise even when the marker is in flight (#6640) Previously the closed promise of a Channel was kept or broken only by a reader that saw the close or fail marker at the head of the queue after taking a value, or by close itself when the queue was already empty. A reader that shifts the marker pushes it straight back, which leaves the queue empty for a moment. A reader taking the last value in that moment ... (14 more lines) |
20:08 | ||
| roast: 23cfb5fbdd | (Nick Logan)++ (committed using GitHub Web editor) | S05-metasyntax/regex.t Test block quantifier limits when backtracked into (#905) A capture, a named regex, an exhaustive match, a frugal quantifier and a separated frugal quantifier each restart a cursor holding a `** {code}` quantifier and must keep the limits that quantifier computed. Covers rakudo/rakudo#5588 |
20:17 | ||
| linkable6 | ROAST#905 [closed]: github.com/Raku/roast/pull/905 Test block quantifier limits when backtracked into | ||
| linkable6 | RAKUDO#5588 [closed]: github.com/rakudo/rakudo/issues/5588 [regex][Will be addressed in RakuAST] Regex quantifier with {} doesn't match the correct number of characters in some cases | ||
| Geth | roast: 0041559fa0 | (Nick Logan)++ (committed using GitHub Web editor) | S05-capture/caps.t Test that backtracking drops captures seen by code blocks (#906) A code block and an assertion after a quantified capture must see only the captures the regex has not backtracked past. Covers rakudo/rakudo#4105 |
||
| linkable6 | ROAST#906 [closed]: github.com/Raku/roast/pull/906 Test that backtracking drops captures seen by code blocks | ||
| linkable6 | RAKUDO#4105 [closed]: github.com/rakudo/rakudo/issues/4105 [regex] With `(foo)+` the corresponding sub-captures aren't removed during backtracking | ||
| Geth | roast: 96258a1b4c | (Nick Logan)++ (committed using GitHub Web editor) | S05-metasyntax/charset.t Test lookarounds over compound character classes (#907) Previously a lookahead over a character class that mixes backslash sequences with characters, or subtracts one class from another, consumed a character, and a negated one was not inverted at all. A plus sign in front of a negated backslash sequence subtracted instead of adding, and a lookahead over an empty enumeration always matched. This ... (5 more lines) |
||
| linkable6 | ROAST#907 [closed]: github.com/Raku/roast/pull/907 Test lookarounds over compound character classes | ||
| roast: 7f9846e0a9 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Test escapes and combining characters in character classes (#908) Covers ignoremark character classes that sit in an alternation, hex and named escapes under :ignorecase and :ignoremark, case forms that are not a single character, and a base character followed by a combining escape forming one entry of the class. rakudo/rakudo#2962 |
|||
| linkable6 | ROAST#908 [closed]: github.com/Raku/roast/pull/908 Test escapes and combining characters in character classes | ||
| linkable6 | RAKUDO#2962 [closed]: github.com/rakudo/rakudo/issues/2962 [Unicode][regex] A Synthetic in a character range, interferes with :ignoremark | ||
| Geth | rakudo: ugexe++ created pull request #6647: RakuAST: split long decimal numbers before converting them to Int |
20:57 | |
| rakudo: ugexe++ created pull request #6648: Compare routine identity instead of addresses in the qualified call test |
21:20 | ||
| rakudo/main: 93df74e3f8 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Compare routine identity instead of addresses in the qualified call test (#6648) Previously the shared module state test proved both consumers reached the same routine by comparing two .WHERE results taken in separate calls. A closure clone bound into the stash at module load lives in the nursery, and a nursery collection between the two calls moves it, so the same object reported two addresses and the test failed at ... (10 more lines) |
21:59 | ||
| rakudo: ugexe++ created pull request #6649: RakuAST: look up a sigiled indirect name at run time |
22:22 | ||
| nqp: ugexe++ created pull request #871: Ugexe/altseq terminates ltm |
22:29 | ||
| rakudo/main: 13e3f3a30c | (Nick Logan)++ (committed using GitHub Web editor) | 2 files RakuAST: look up a sigiled indirect name at run time (#6649) Previously a sigiled indirect name written with a constant string, like &::("foo") or $::("bar"), compiled as a plain lexical of that name. The runtime symbolic lookup consults the symbols a require merged into the caller before anything visible at compile time, so a require-injected sub was never seen, while the legacy frontend compiles these as runtime lookups. This compiles a sigiled indirect name as a package variable, which emits the runtime lookup with the sigil. |
22:59 | ||
| [Coke] | another blin in progress. | 23:32 | |
| Geth | rakudo: ugexe++ created pull request #6650: Backtrack into interpolated regex alternatives |
23:41 | |
| rakudo: ugexe++ created pull request #6651: Match the initializer symbol before rejecting a signature declaration |
23:55 | ||