[00:52] <Geth> ¦ rakudo: ugexe++ created pull request #6652: Measure a case-folded interpolation match against the target

[00:52] <Geth> ¦ rakudo: review: https://github.com/rakudo/rakudo/pull/6652

[00:53] <Geth> ¦ rakudo: ugexe++ created pull request #6653: Throw for a hash used as a regex assertion

[00:53] <Geth> ¦ rakudo: review: https://github.com/rakudo/rakudo/pull/6653

[01:54] *** kurahaupo left
[02:11] *** coleman left
[02:11] *** summerisle left
[02:11] *** ugexe left
[02:27] *** coleman joined
[02:27] *** summerisle joined
[02:27] *** ugexe joined
[03:31] <Geth> ¦ rakudo: ugexe++ created pull request #6654: Match the lookahead greedily in the LTM before-assertion test

[03:31] <Geth> ¦ rakudo: review: https://github.com/rakudo/rakudo/pull/6654

[03:34] <Geth> ¦ rakudo/main: f4f55b2775 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files

[03:34] <Geth> ¦ rakudo/main: Match the initializer symbol before rejecting a signature declaration (#6651)

[03:34] <Geth> ¦ rakudo/main: 

[03:34] <Geth> ¦ rakudo/main: Previously initializer:sym<=> checked for a signature declaration before

[03:34] <Geth> ¦ rakudo/main: matching its symbol, so that group led the candidate and set its

[03:34] <Geth> ¦ rakudo/main: declarative prefix. Once a sequential alternation ends the prefix, that

[03:34] <Geth> ¦ rakudo/main: candidate has an empty prefix and gets tried on any input. A my :(...)

[03:34] <Geth> ¦ rakudo/main: declaration with no initializer at all then died with the assignment

[03:34] <Geth> ¦ rakudo/main: error instead of the missing initializer one.

[03:34] <Geth> ¦ rakudo/main: 

[03:34] <Geth> ¦ rakudo/main: This matches the symbol first, so the candidate is only tried when an

[03:34] <Geth> ¦ rakudo/main: assignment is actually there.

[03:34] <Geth> ¦ rakudo/main: review: https://github.com/rakudo/rakudo/commit/f4f55b2775

[04:01] <Geth> ¦ nqp/main: 8172e76567 | (Nick Logan)++ | 2 files

[04:01] <Geth> ¦ nqp/main: Stop the declarative prefix at a sequential alternation

[04:01] <Geth> ¦ nqp/main: 

[04:01] <Geth> ¦ nqp/main: Previously the NFA for a sequential alternation covered its first

[04:01] <Geth> ¦ nqp/main: branch and an empty path, then kept going with whatever followed the

[04:01] <Geth> ¦ nqp/main: group. That made the declarative prefix of `[ x || y ] z` behave like

[04:01] <Geth> ¦ nqp/main: `x? z`, so a branch of a longest token alternation containing that

[04:01] <Geth> ¦ nqp/main: group was never tried on input such as `yz` even though `y` matches

[04:01] <Geth> ¦ nqp/main: <…commit message has 6 more lines…>

[04:01] <Geth> ¦ nqp/main: review: https://github.com/Raku/nqp/commit/8172e76567

[04:02] <Geth> ¦ nqp/main: 26181555c8 | (Nick Logan)++ | src/QRegex/NFA.nqp

[04:02] <Geth> ¦ nqp/main: Stop building a repetition after the declarative prefix has ended

[04:02] <Geth> ¦ nqp/main: 

[04:02] <Geth> ¦ nqp/main: Previously the counted repetition loop kept calling the builder with

[04:02] <Geth> ¦ nqp/main: whatever state the previous repetition returned, and a repetition that

[04:02] <Geth> ¦ nqp/main: ended the declarative prefix returns no state. The loop then pushed

[04:02] <Geth> ¦ nqp/main: edges onto the fate list, and a sequential alternation under a counted

[04:02] <Geth> ¦ nqp/main: quantifier is a common way to end the prefix.

[04:02] <Geth> ¦ nqp/main: 

[04:02] <Geth> ¦ nqp/main: This leaves the loop once a repetition ends the prefix. Only the paths

[04:02] <Geth> ¦ nqp/main: that skipped the remaining repetitions carry on.

[04:02] <Geth> ¦ nqp/main: review: https://github.com/Raku/nqp/commit/26181555c8

[04:02] <Geth> ¦ nqp/main: f639323a13 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files

[04:02] <Geth> ¦ nqp/main: Merge pull request #871 from ugexe/ugexe/altseq-terminates-ltm

[04:02] <Geth> ¦ nqp/main: 

[04:02] <Geth> ¦ nqp/main: Stop the declarative prefix at a sequential alternation

[04:02] <Geth> ¦ nqp/main: review: https://github.com/Raku/nqp/commit/f639323a13

[04:04] <Geth> ¦ rakudo: ugexe++ created pull request #6655: Bump NQP to stop the declarative prefix at a sequential alternation

[04:04] <Geth> ¦ rakudo: review: https://github.com/rakudo/rakudo/pull/6655

[04:46] <Geth> ¦ rakudo/main: ab802d1eef | (Nick Logan)++ (committed using GitHub Web editor) | t/02-rakudo/ltm-before-assertion.t

[04:46] <Geth> ¦ rakudo/main: Match the lookahead greedily in the LTM before-assertion test (#6654)

[04:46] <Geth> ¦ rakudo/main: 

[04:46] <Geth> ¦ rakudo/main: Previously the test grammar looked ahead with `.+?`, which only

[04:46] <Geth> ¦ rakudo/main: contributed to the declarative prefix because the NFA treated a frugal

[04:46] <Geth> ¦ rakudo/main: quantifier like a greedy one. S05 ends the longest token at a frugal

[04:46] <Geth> ¦ rakudo/main: quantifier, so the test would then assert nothing about the lookahead

[04:46] <Geth> ¦ rakudo/main: being inlined, which is what it was written for.

[04:46] <Geth> ¦ rakudo/main: 

[04:46] <Geth> ¦ rakudo/main: This looks ahead with `.+` instead. Inside a lookahead nothing is

[04:46] <Geth> ¦ rakudo/main: consumed, so the assertion succeeds on the same input either way.

[04:46] <Geth> ¦ rakudo/main: review: https://github.com/rakudo/rakudo/commit/ab802d1eef

[05:16] <Geth> ¦ rakudo/main: 6b984fe73f | (Nick Logan)++ (committed using GitHub Web editor) | tools/templates/NQP_REVISION

[05:16] <Geth> ¦ rakudo/main: Bump NQP to stop the declarative prefix at a sequential alternation (#6655)

[05:16] <Geth> ¦ rakudo/main: review: https://github.com/rakudo/rakudo/commit/6b984fe73f

[05:20] *** kurahaupo joined
[05:23] <Geth> ¦ rakudo/main: 2d14ad281b | (Nick Logan)++ (committed using GitHub Web editor) | 2 files

[05:23] <Geth> ¦ rakudo/main: RakuAST: split long decimal numbers before converting them to Int (#6647)

[05:23] <Geth> ¦ rakudo/main: 

[05:23] <Geth> ¦ rakudo/main: Previously the literal builder handed a whole decimal digit string to

[05:23] <Geth> ¦ rakudo/main: the VM bigint parser, which is quadratic in the digit count. A capture

[05:23] <Geth> ¦ rakudo/main: variable, integer literal, or regex quantifier bound with a million

[05:23] <Geth> ¦ rakudo/main: digits took around a minute to compile, while the legacy frontend

[05:23] <Geth> ¦ rakudo/main: parsed the same capture index into a native int in under a second.

[05:23] <Geth> ¦ rakudo/main: <…commit message has 7 more lines…>

[05:24] <Geth> ¦ rakudo/main: review: https://github.com/rakudo/rakudo/commit/2d14ad281b

[05:26] <Geth> ¦ rakudo/main: d6ada9bd14 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files

[05:26] <Geth> ¦ rakudo/main: Backtrack into interpolated regex alternatives (#6650)

[05:26] <Geth> ¦ rakudo/main: 

[05:26] <Geth> ¦ rakudo/main: Previously an array (or list, or any junction) interpolated into a regex

[05:26] <Geth> ¦ rakudo/main: was tried once: INTERPOLATE walked every candidate the NFA passed and

[05:26] <Geth> ¦ rakudo/main: returned the longest match as a plain cursor. When the rest of the regex

[05:26] <Geth> ¦ rakudo/main: failed after it there was nothing to backtrack into, so

[05:26] <Geth> ¦ rakudo/main: `'abc' ~~ / @(< a ab >) b /` was Nil where the literal `< a ab >` form

[05:26] <Geth> ¦ rakudo/main: <…commit message has 17 more lines…>

[05:26] <Geth> ¦ rakudo/main: review: https://github.com/rakudo/rakudo/commit/d6ada9bd14

[06:17] *** kurahaupo left