Chapter 3 of 9

Near-misses outnumber borrowings seven to one

Record	Date	Perl 6 / Raku mention	Outcome
Python PEP 344 → PEP 3134, exception chaining	created 12 May 2005; final in Python 3.0	RFC 88 (Tony Olekshy, 8 Aug 2000) chained exceptions in `@@`, surveyed beside Java, Ruby, C# (PEP 3134¹); on 20 May 2005 the author, Ka-Ping Yee, told python-dev that Perl 6's proposed `@@` was the only precedent he had found for implicit chaining (python-dev²)	Shipped as `raise … from`, `__cause__`, `__context__`; cited as prior art
Python PEP 3133, Roles	1 May 2007	Takes Squeak traits primarily via Perl 6 roles, including runtime application to instances (PEP 3133³)	Rejected 24 May 2007, Guido preferring ABCs that can be subclassed and carry concrete methods; ABCs (PEP 3119) instead (python-3000⁴; acceptance⁵)
PHP traits / Horizontal Reuse RFCs	6 Mar 2008; 12 Oct 2008	Perl 6 listed among languages that integrated traits (traits⁶; horizontalreuse⁷)	PHP 5.4 traits from the Bern Traits papers; prior art
Traits authors, TOPLAS	March 2006	Perl 6 roles listed as an adopter in progress (TOPLAS 2006⁸)	Perl 6 as adopter, not source
Siek, "What is Gradual Typing"	undated, c. 2007–08	Perl 6 named with Python 3k and ES4 as languages the theory should underpin (Siek⁹)	Theory credits Thatte and Strongtalk, not Perl 6
Partial application: Python PEP 309 naming; Ruby #7939; PHP Partial Function Application v2	24 Feb 2004; 24 Feb 2013 – 24 Feb 2014; 2020	Gisle Aas notes that Perl 6 plans `f.assuming()` (python-dev¹⁰); a Ruby request praises Perl 6's `assuming` (#7939¹¹); PHP's RFC names Raku's `.assuming` as the notable exception (RFC¹²)	Python chose `functools.partial` (PEP 309¹³); nobu called it partial application, not currying, and Matz asked for a new name, leaving the issue in Feedback (note-8¹⁴); PHP declined 29–20
PHP Pattern Matching RFC	v0.9; in discussion from 1 Dec 2025	Future range pattern possibly modelled on Raku `Range` (RFC¹⁵)	Pending
C# ranges, csharplang #185 and discussion #198	27 Feb 2017	Commenter proposes Perl 6's `a^..^b` family; HaloFour's companion discussion lists `5 ^.. 10` (comment¹⁶; #198¹⁷)	C# 8 shipped `..` plus `^n`; a Roslyn team member called Perl's `^` usage irrelevant (comment¹⁸)
Ruby #12133; #21284	15 Mar 2016; 27 Apr 2025	Core committer nobu suggests Perl 6's start-exclusive `^..`, and nine years later still names it as the thing Ruby lacks (#12133¹⁹; #21284 note-3²⁰)	Not adopted
Dart language #2105, ranges in switch cases	comment 21 Apr 2022	Bob Nystrom surveys Raku's `..`, `^..`, `..^`, `^..^` beside Perl, Ruby, Swift and Rust (comment²¹)	Closed 13 Sep 2022 in favour of relational patterns (`case >= 0x30 & <= 0x39`) and guards (closing comment²²)
Rust #28237; Zig #359	18 Mar 2017; 23 Apr 2020 – 21 Jan 2021	When `..^` was floated for Rust's inclusive range, Scott Olson objected that Perl 6 uses it for the exclusive one; a Zig user proposed Raku's `..^` and `^..^` for switch ranges (#28237²³; zig#359²⁴)	Rust kept `..=`, stable in 1.26.0 (RELEASES.md²⁵); Andrew Kelley closed the Zig issue, keeping exclusive `a..b` for slices and inclusive `a...b` for switch cases
Ruby #16894; Crystal #2968	17 May 2020; 27 Jun 2018	Commenter praises Raku and Clojure default rationals; a Crystal contributor lists an `Int / Int` that returns a `BigRational`, as Perl 6 does, as one option, then prefers Crystal's existing division (#16894²⁶; crystal#2968²⁷)	Ruby: no decision; Crystal 0.31.0 (23 Sep 2019) made `/` float division (changelog²⁸)
TC39 Decimal README	13 Nov 2019; restored 30 Jun 2026	Champion Daniel Ehrenberg lists Perl 6's `1.5` Rat literals under Rationals, beside Common Lisp, Scheme and Ruby (README²⁹)	Still Stage 1; the README declines rationals for this proposal, citing denominator growth, GCD normalisation and irrational `exp`/`log`
PHP internals, letter decrementing	18–19 Jul 2013	Peter Lind cites S03: Perl 6 decrements strings, though not as an exact mirror of increment (68184³⁰)	No change in 2013; precursor of the 2023 increment RFC
Swift character-class pitch	19 Oct 2021	Raku row (grapheme dot, normalized strings) in engine survey (pitch³¹)	Dropped from SE-0363's text
Julia #14383, string redesign	17–18 Jan 2016	A commenter cites NFG's constant-time grapheme indexing; core member Milan Bouchet-Valat answers that it makes sense only when starting from UTF-32 and wastes memory (comment³²)	Considered, rejected; Julia indexes UTF-8 bytes and iterates graphemes in its `Unicode` stdlib (manual³³)
pgsql-hackers, ANY/ALL	13 Jun 2011	Generalised quantifiers compared to Perl 6 junctions (thread³⁴)	Discussion only
Swift substring-predicate pitch	11 Apr 2023	Language Workgroup member Becca Royal-Gordon likens it to Raku junctions and argues that their unrestricted form hides loops, obscuring time complexity, and that overloading would burden type-checking (#10³⁵)	Considered, rejected; she recommended a package, and the pitch was not pursued
F# suggestion #675	21 Jun 2018; declined 16 Jun 2022	A user offers Perl 6's `42 == 30 \| 42 \| 100` (comment³⁶)	Declined by Don Syme: not for the language itself, since it can be programmed in other ways (#675³⁷)
D, "make (a < b < c) illegal?"	8 Feb 2007	Andrei Alexandrescu notes that Perl 6 is to implement chained comparisons (post³⁸)	Walter Bright agreed to make comparisons non-associative; D's grammar rejects `a < b < c`, leaving chaining possible later (D spec³⁹)
es-discuss; Rust internals pre-RFC	18 Jul 2013; 12 Oct 2020	Andy Earnshaw cites Python, Perl 6 and CoffeeScript; kennytm, later on the libs team, describes Python's and Raku's short-circuiting (msg24857⁴⁰; #20⁴¹)	Neither adopted; Rust comparisons still require parentheses (Reference⁴²)
C# chained relational comparison	community discussion 20 Jan 2023; champion issue 11 Dec 2024; spec text 19 Apr 2026; approved at the design meeting of 27 Apr 2026	A 2023 discussion asks for chaining after reading about Raku (#6899⁴³), though the champion issue links a different one; the proposal lists "Raku / Perl 6" among languages with native chaining, beside CPL, Python, Julia, Mathematica, the Lisps, CoffeeScript and Icon (proposal⁴⁴; #8861⁴⁵)	Cited as prior art; the meeting notes name Python as the model, and the feature is not in C# 15 (LDM 2026-04-27⁴⁶)
Rust RFC 2909, destructuring assignment	start date 17 Apr 2020	Prior-art list entry labelled "Perl" links a 2017 Perl 6 Advent post on signature destructuring (RFC 2909⁴⁷)	Shipped (Rust 1.59); cited as prior art, beside JavaScript and Python
Kotlin KEEP design note "Code Coloring"	note by Ilmir Usmanov, first committed 9 Feb 2021; KEEP #240 opened 9 Mar 2021	Raku named with Go and Project Loom as languages where any function may suspend, so functions are not coloured (note⁴⁸; KEEP #240)	Cited as prior art in a design note; Kotlin keeps `suspend`
Rust RFC PRs #1216 and #1564	2015–2016	Commenters propose Perl 6's `Mu` as the name of `!` and Perl 6's `proto`/`multi` for function clauses (#1216⁴⁹; #1564⁵⁰)	Neither taken: `!` became the never type, and #1564 was closed unmerged
Rust #2394, closure syntax	21–22 May 2012	Core-team member Patrick Walton proposes Perl 6's `-> args block`, for fewer shifted characters and braces at line end (comment⁵¹)	Niko Matsakis preferred `\|\| { … }` as more consistent; Walton closed the issue the next day, and Rust closures are written `\|args\| expr`
es-discuss, arrow functions	18 Jan 2012	Brendan Eich sketches a prefix `->` arrow, suggested to him with reference to Ruby 1.9 and Perl 6 (msg12716⁵²)	ES2015 shipped the infix `=>`
Go #35386, `...` statement	5–26 Nov 2019	Go team member Brad Fitzpatrick proposes a statement that compiles but panics, linking Raku's `...` stub (#35386⁵³)	Rob Pike objected that it would block `go test`; Fitzpatrick withdrew it
GHC proposals #754, "Dash sections"	29 Apr 2026	Lists Raku's `*` beside Lean, Mathematica, Scala, PureScript and C++ placeholders (#754⁵⁴)	Open pre-proposal; cited as prior art
Carbon p0680, `and`/`or`/`not`	Jul 2021	Survey notes that Perl, Ruby and Raku have both spellings, the punctuation forms binding tighter, and mentions `andthen`/`orelse` (p0680⁵⁵)	Leads chose keyword-only operators on `bool` (31 Jul 2021) and rejected returning the deciding operand (#684⁵⁶)
TypeScript #5326	17 Jan 2019	A user proposes properties filled from named arguments without a constructor, inspired by Perl 6 (comment⁵⁷)	Not taken; issue open
Ruby #5011; Go #17178, CLI from `main` parameters	10 Jul 2011 – 21 Jul 2012; 21 Sep 2016	Requests to bind command-line arguments to a program's main routine as Perl 6's `MAIN` does (#5011⁵⁸; go#17178⁵⁹)	Ruby's developer meeting rejected it, Matz preferring to improve optparse (note-7⁶⁰); Fitzpatrick declined Go's about an hour later
Regex reform: CPython bpo-2636; Rust #3591; python-ideas	23 Mar 2009; 17 Apr 2014; 16 Nov 2017	Matthew Barnett does not want `re` to go the way of Perl 6 rules (msg83993⁶¹); Andrew Gallant defers grammar-based regexes to libraries (comment⁶²); Guido declines to change `re.VERBOSE` whitespace merely because Perl 6 does (python-ideas⁶³)	Neither standard library changed; recursion reached only Barnett's third-party `regex` (PyPI⁶⁴)
Passing mentions	2000–2026	Matz on Perl 6's `use` when naming refinements' `using` (#4085⁶⁵); Swift reviews citing Perl 6's `is tighter` precedence and `Stringy` (SE-0077⁶⁶; #14⁶⁷); Clugston calling A5 a must-read for D (post⁶⁸); PHP wishes for junctions, and Andrea Faulds agreeing with Rowan Collins's praise of NFG (92870⁶⁹; 78213⁷⁰); Python posts on hyper-operators, feeds and Unicode operators (2004⁷¹; 2006⁷²; 2016⁷³); Rust's `tau` (#66616⁷⁴); Karpinski on multiple dispatch (Julia⁷⁵); single remarks on the Kotlin, Haskell, OCaml, Crystal, Zig and Nim forums	Nothing taken from Perl 6; Rust's `TAU` shipped in 1.47 on Python's precedent, with Perl 6 and Nim named after it

What the sources say 75

Ka-Ping Yee, PEP author PEP 3134, Exception Chaining and Embedded Tracebacks, Rationale 12 May 2005; Final in Python 3.0 source ↗
As for other languages, Java and Ruby both discard the original exception when another exception occurs in a catch/rescue or finally/ensure clause. Perl 5 lacks built-in structured exception handling. For Perl 6, RFC number 88 proposes an exception mechanism that implicitly retains chained exceptions in an array named @@. In that RFC, the most recently raised exception is exposed for matching, as in this PEP; also, arbitrary expressions (possibly involving @@) can be evaluated for exception matching.
The next paragraph turns to C#, whose InnerException property is set explicitly through exception constructors rather than by the runtime.
Ka-Ping Yee, author of PEP 344 python-dev mailing list 20 May 2005 source ↗
Describing his research into implicit exception chaining, Yee tells python-dev that Perl 6's proposed @@ was the sole precedent he managed to find.
Collin Winter, PEP author; rejection notice by Guido van Rossum PEP 3133, Introducing Roles 1 May 2007; Rejected source ↗
This system was originally called "traits" and implemented for Squeak Smalltalk. It has since been adapted for use in Perl 6 where it is called "roles", and it is primarily from there that the concept is now being interpreted for Python 3. Python 3 will preserve the name "roles".
Guido van Rossum's rejection notice, at the top of the PEP, says it pushed PEP 3119, the abstract base classes Python adopted instead, toward a simpler design, and that he prefers that PEP as it now stands. The PEP's examples are adapted from Curtis Poe's article on Perl 6 roles.
Guido van Rossum, Python's creator python-3000 mailing list, PEP 3133 discussion, message 007666 15 May 2007 source ↗
Guido says that even if roles had equal standing he would still choose ABCs, since an ABC can serve as a base class and supply implemented methods, and questions what roles would contribute beyond them.
Guido van Rossum, Python's creator python-3000 mailing list, Accepting PEP 3119, rejecting PEP 3133, message 007913 24 May 2007 source ↗
Guido announces his decision on the two competing proposals: PEP 3119's abstract base classes are accepted and PEP 3133's roles are rejected.
Stefan Marr, RFC author PHP RFC: Traits for PHP, version 1.5 6 Mar 2008 source ↗
The RFC names Perl 6 among languages that have integrated traits, alongside Scala, Squeak, Fortress and Slate, and bases its design on the Bern group's traits papers by Schärli and Ducasse.
Stefan Marr, RFC author PHP RFC: Horizontal Reuse for PHP 12 Oct 2008; implemented in PHP 5.4 (traits only) source ↗
The successor RFC again cites Perl 6 as a language with traits, listing implementations for it among others, and draws its bibliography from the Bern traits papers and Schärli's thesis.
Stéphane Ducasse, Oscar Nierstrasz, Nathanael Schärli, Roel Wuyts and Andrew Black, the traits authors ACM TOPLAS 28(2), Traits: A Mechanism for Fine-Grained Reuse March 2006 source ↗
The authors list Scala and a Perl 5 implementation as existing adopters and report work under way to build traits, called roles there, into the forthcoming Perl 6 as a standard feature.
Jeremy Siek, co-originator of gradual typing What is Gradual Typing, essay on his website undated, c. 2007–08 source ↗
Siek names Perl 6, Python 3k and ECMAScript 4 as languages in development that add optional type annotations, and offers gradual typing as the theory underpinning what they do.
Gisle Aas, ActiveState, author of Perl's LWP python-dev mailing list, PEP 309 naming discussion 24 Feb 2004 source ↗
During the debate over what to call PEP 309's partial-application function, Aas points out that Perl 6 intends to offer the same thing as an assuming method.
Kresimir Bojcic, feature requester; reply by Nobuyoshi Nakada (nobu), core committer Ruby issue tracker, Feature #7939, Alternative curry function creation 24 Feb 2013 source ↗
Bojcic says he likes Perl 6's new assuming method and asks Ruby for something like it, finding curry too mathematical; nobu replies that this is partial application rather than currying.
Paul Crovella, Levi Morrison, Joe Watkins and Larry Garfield, RFC authors PHP RFC: Partial Function Application, version 2 22 Apr 2020; vote 16–30 Jun 2021 source ↗
Comparing languages, the RFC says native partial application mostly lives in auto-currying functional languages and calls Raku, via its assuming method, the notable exception; the vote went 29 to 20, short of two thirds.
Peter Harris, PEP author PEP 309, Partial Function Application 8 Feb 2003; Final in Python 2.5 source ↗
Patch #941881 was accepted and applied in 2005 for Py2.5. It is essentially as outlined here, a partial() type constructor binding leftmost positional arguments and any keywords.
A note added after acceptance says the module proposed to hold it, functional, was renamed functools once other tools for functions were wanted there too.
Yukihiro Matsumoto (Matz), Ruby's creator Ruby Feature #7939, note 8 24 Feb 2014 source ↗
Matz says Ruby will keep curry faithful to the mathematical meaning of currying, accepts that the proposed API may be intuitive, and says what it lacks is a new name.
Larry Garfield and Ilija Tovilo, RFC authors PHP RFC: Pattern Matching, v0.9 dated 11 Nov 2020; in discussion from 1 Dec 2025 source ↗
The RFC leaves range patterns for later and suggests that a future RFC on ranges could model its pattern on Raku's Range or a similar design.
bbarry, csharplang contributor dotnet/csharplang issue #185, ranges champion issue, comment 27 Feb 2017 source ↗
bbarry praises Perl 6's range specification and lists its four forms: both endpoints included, start excluded, end excluded, and both excluded, each exclusion marked by a caret beside the dots.
HaloFour, csharplang community member dotnet/csharplang discussion #198, range-operator questions 27 Feb 2017 source ↗
HaloFour's list of open questions about range operators includes a Perl 6-style example, labelled perl, in which 5 ^.. 10 yields the values 6 through 10.
Cyrus Najmabadi, Roslyn compiler team dotnet/csharplang issue #185, comment 28 Jun 2018 source ↗
Najmabadi argues that the caret's meaning in Perl, regular expressions, Fortran and elsewhere does not bear on how C# should use it.
Nobuyoshi Nakada (nobu), Ruby core committer Ruby Feature #12133, Ability to exclude start when defining a range, note 2 15 Mar 2016 source ↗
Answering a request for ranges that can exclude their start, nobu says mixing bracket types would cause trouble, editors included, and floats Perl 6's neko operator as an alternative.
Nobuyoshi Nakada (nobu), Ruby core committer Ruby Feature #21284, Request: add Array#pad method, note 3 27 Apr 2025 source ↗
After suggesting a ^.. range earlier in the thread, nobu concedes that Ruby has no start-exclusive range and explains that ^.. is Perl 6's so-called neko operator, which the request recalled.
Bob Nystrom, Dart language team dart-lang/language issue #2105, Ranges in switch cases, comment 21 Apr 2022 source ↗
Surveying range syntax across languages, Nystrom describes Raku's inclusive .. and its caret forms that exclude the left end, the right end or both, next to Perl, Ruby, Swift and Rust.
Bob Nystrom, Dart language team, closing a request opened by Ian Hickson dart-lang/language issue #2105, Ranges in switch cases opened 9 Feb 2022; closed 13 Sep 2022 source ↗
Nystrom closes the request, explaining that relational patterns joined with &, as in >= 0x30 & <= 0x39, plus guards cover the need, and that Dart's grammar is already crowded with punctuation.
Scott Olson, Rust contributor rust-lang/rust issue #28237, tracking issue for inclusive ranges, comment 18 Mar 2017 source ↗
When ..^ is floated as the spelling for Rust's inclusive range, Olson objects that Perl 6 already uses that syntax with the opposite, exclusive meaning.
ManDeJan, Zig user (not a project member) ziglang/zig issue #359, comment 23 Apr 2020 source ↗
Saying Raku's approach appeals to them, the commenter proposes marking excluded endpoints with a caret in switch ranges, as in 10 ^..^ 15 or 0 ..^ 5.
Rust project, release notes RELEASES.md, Version 1.26.0, Language 10 May 2018 source ↗
The language notes for Rust 1.26.0 report that ..= ranges, which include their end point, are now stable.
Shannon Skipper, commenter Ruby Feature #16894, Integer division for Ruby 3, note 17 17 May 2020 source ↗
Preferring to avoid floats where possible, Skipper finds the Raku and Clojure default of dividing to a rational appealing and likes that Raku's rationals print as decimal digits.
j8r, Crystal contributor crystal-lang/crystal issue #2968, comment 27 Jun 2018 source ↗
j8r mentions that integer division could instead return a BigRational, as Perl 6 does, but adds a personal preference for Crystal's existing division behaviour.
Crystal core team, changelog doc/changelogs/pre-1.0.md, release 0.31.0 23 Sep 2019 source ↗
The 0.31.0 changelog lists, as a breaking change, making / arithmetic rather than integer division for all types (PR #8120).
Daniel Ehrenberg, proposal champion; entry restored by Jesse Alama tc39/proposal-decimal README, Rationals 13 Nov 2019; restored 30 Jun 2026 source ↗
The README's survey of rationals notes that Perl 6 literals such as 1.5 are Rat values, beside Ruby, Scheme and Common Lisp, then explains why this proposal does not adopt rationals.
Peter Lind, PHP internals participant PHP internals, thread Allow letter decrementing, message 68184 19 Jul 2013 source ↗
Lind points to Synopsis 3 to show that Perl 6 can decrement strings, while noting that its decrement does not exactly reverse its increment.
Nate Cook, pitch author Swift Forums, [Pitch] Character Classes for String Processing 19 Oct 2021 source ↗
The pitch's broad survey of languages and regex engines gives Raku a row: its dot matches a grapheme cluster, its strings are always normalised, and \d matches full-width digits.
Milan Bouchet-Valat, Julia member JuliaLang/julia PR #14383, string redesign, comment 18 Jan 2016 source ↗
Responding to the NFG suggestion, Bouchet-Valat argues the scheme pays off only for strings starting as UTF-32, not UTF-8, and would waste a great deal of memory.
Julia manual JuliaLang/julia doc/src/manual/strings.md, Strings chapter current text, read Nov 2026 source ↗
The manual explains that Julia string indices count code units, which for UTF-8 strings are bytes, rather than characters.
Stephen J. Butler, pgsql-hackers participant pgsql-hackers mailing list, postgrespro archive 13 Jun 2011 source ↗
Discussing a generalisation of ANY()/ALL() to operators that do not commute, Butler remarks that the idea is approaching Perl 6's junctions, or superpositions.
Becca Royal-Gordon, Swift Language Workgroup Swift Forums, pitch on simplifying substring searching with custom operators and predicates, post 10 11 Apr 2023 source ↗
Royal-Gordon likens the pitch to Raku junctions, warns that their unrestricted form hid loops and obscured time complexity and that overloading would burden type-checking, and suggests shipping a package instead.
pavelbraginskiy, F# user (not a project member) fsharp/fslang-suggestions issue #675, comment 21 Jun 2018 source ↗
The commenter notes that Perl 6 roughly supports this through a junction comparing 42 with any of 30, 42 and 100, then suggests a shorthand for matching a value against one pattern.
Don Syme, F# language designer fsharp/fslang-suggestions issue #675, Add a multi-value equality check opened 18 Jun 2018; declined 16 Jun 2022 source ↗
Syme declines the suggestion, saying F# will not add it to the language itself because the alternatives already given in the thread handle nearly every use case.
Andrei Alexandrescu, D language co-designer digitalmars.D newsgroup, thread make (a < b < c) illegal? 8 Feb 2007 source ↗
In the thread on banning a < b < c, Alexandrescu remarks in passing that Perl 6 is due to implement chained comparisons too.
D language specification D spec, Expressions chapter, relational expressions current text, read Nov 2026 source ↗
The grammar gives each relational expression exactly two shift-expression operands, so comparison operators do not associate and an unparenthesised chain is not a valid expression.
Andy Earnshaw, es-discuss participant es-discuss mailing list, Chained comparisons from Python and CoffeeScript 18 Jul 2013 source ↗
Earnshaw raises chained comparisons for ECMAScript, pointing to Python, Perl 6 and CoffeeScript as languages that already support them.
kennytm, later on Rust's libs team internals.rust-lang.org, Pre-RFC: Python-like chained comparison operators, post 20 12 Oct 2020 source ↗
kennytm explains that in Python and Raku a chained comparison short-circuits: once the first comparison fails, the following operand is never evaluated.
The Rust Reference, Rust project Expressions chapter, operator precedence table current text, read Nov 2026 source ↗
The precedence table marks the comparison operators as requiring parentheses rather than associating, so a < b < c must be written with explicit grouping.
The-Futurist, csharplang community member dotnet/csharplang discussion #6899 20 Jan 2023 source ↗
The-Futurist asks C# for chained comparisons, explaining the interest came from reading about Raku while studying the feature for a new language; HaloFour points to the earlier request #4108.
Cyrus Najmabadi, proposal author and champion dotnet/csharplang proposals/chained-relational-comparison.md 19 Apr 2026 source ↗
The proposal's prior-art survey lists Raku / Perl 6 with native support among other chaining languages, beside CoffeeScript, Icon and BCPL/CPL, after math-oriented languages and the Lisp family.
Cyrus Najmabadi, Roslyn team, feature champion dotnet/csharplang issue #8861, [Proposal]: Chained relational comparison 11 Dec 2024 source ↗
The champion issue proposes reading x < y < z as x < y && y < z and directs debate to discussion #8643.
C# Language Design Meeting dotnet/csharplang meetings/2026/LDM-2026-04-27.md 27 Apr 2026 source ↗
The meeting approves chained relational comparisons as is, calling them common in mathematical languages such as Python, and ranks the feature fourth of five in implementation priority.
varkor, RFC author, with co-author fanzier rust-lang/rfcs RFC 2909, Destructuring assignment, Prior art start date 17 Apr 2020 source ↗
The prior-art section lists JavaScript, Python and Perl as supporting destructuring assignment, with the Perl entry linking a 2017 Perl 6 Advent post on destructuring arguments with signatures.
Ilmir Usmanov, Kotlin Language Research Team Kotlin/KEEP notes/0002-code-coloring.md, Design Notes: Code Coloring 9 Feb 2021; discussion opened 9 Mar 2021 (KEEP #240) source ↗
The note explains that Kotlin colours functions with suspend and others use async, and that some languages need no modifier because every function can suspend, citing Go, Raku and Java's Loom.
canndrew, author of RFC 1216 rust-lang/rfcs PR #1216, Promote ! to a type, comment 1 Aug 2016 source ↗
Days after the RFC was merged, its author suggests calling the never type Mu, giving Perl 6's use of that name as precedent.
eternaleye, Rust community member rust-lang/rfcs PR #1564, Function clauses, comment 1 Apr 2016 source ↗
eternaleye suggests modelling function clauses on Perl 6, with a proto declaration whose {*} dispatches to separate multi bodies.
Patrick Walton, Rust core team rust-lang/rust issue #2394, closure syntax, comment 21 May 2012 source ↗
Walton proposes adopting Perl 6's pointy-block form, an arrow followed by parameters and a block, for needing fewer shifted characters and letting braces end lines.
Brendan Eich, JavaScript's creator es-discuss mailing list, Block lambda is cool, its syntax isn't 18 Jan 2012 source ↗
Eich sketches a grammar for arrow functions introduced by a prefix ->, crediting the suggestion to satyr, author of Coco, who had pointed to Ruby 1.9 and Perl 6.
Brad Fitzpatrick, Go team golang/go issue #35386, proposal: spec: support ... TODO statement 5–26 Nov 2019 source ↗
Fitzpatrick proposes a ... statement that builds yet panics if executed, linking Raku's ... stub; after objections, including Rob Pike's about go test, he withdraws it on 26 November.
Jaro Reinders, GHC proposals contributor ghc-proposals issue #754, Dash sections 29 Apr 2026 source ↗
The pre-proposal for an explicit marker in tuple sections surveys placeholder syntax elsewhere: Lean's ·, Mathematica's #, _ in Scala and PureScript, C++'s _1, and Raku's *.
Richard Smith, Carbon lead Carbon proposal p0680, And, or, not (PR #680) Jul 2021 source ↗
Its background survey says Raku, like Perl and Ruby, accepts both spellings, punctuation binding tighter, and mentions its andthen/orelse; the alternatives reject returning the deciding operand, as Python, Perl and Raku do.
Richard Smith and the Carbon leads carbon-language/carbon-lang issue #684, question for leads 28–31 Jul 2021 source ↗
Smith's survey in the thread lists C++, Perl, Ruby and Raku as offering both spellings; the leads then decide that and, or and not will all be keywords.
rodrigolive, TypeScript user (not a team member) microsoft/TypeScript issue #5326, comment 17 Jan 2019 source ↗
The commenter proposes a construct keyword so that class properties are filled from the constructor's argument object with no hand-written constructor, describing the idea as inspired by Perl 6.
Rodrigo Rosenfeld Rosas, feature requester Ruby Feature #5011, Add Perl 6-like main method definition support 10 Jul 2011 source ↗
Rosas links a Perl 5-to-6 article and asks Ruby to let a defined main method take its parameters from the command line, offering it as an alternative to issue #4824.
Kroc, requester (not a Go team member); closed by Brad Fitzpatrick, Go team golang/go issue #17178, Proposal: Parameters in main() map to command-line parameters (Perl6) 21 Sep 2016 source ↗
Kroc asks for Perl 6-style mapping of main() parameters to command-line arguments, perhaps in Go 2; about an hour later Fitzpatrick closes it, doubting Go 2 would adopt all features of all languages.
Yusuke Endoh (mame), Ruby core committer, relaying the developer meeting Ruby Feature #5011, note 7 23 Jul 2012 source ↗
Endoh tells the requester that the 21 July developer meeting rejected the proposal; Matz considered improving optparse a reasonable idea but judged this proposal to be heading the wrong way.
Matthew Barnett, author of the regex module Python bug tracker, bpo-2636, msg83993 23 Mar 2009 source ↗
Barnett says Python's re should not head in the direction of Perl 6 rules, which he thinks are better provided outside the module.
Andrew Gallant (BurntSushi), author of Rust's regex work rust-lang/rust issue #3591, comment 17 Apr 2014 source ↗
Gallant agrees grammar-based regexes look appealing but calls them a separate matter, well suited to trying out as an embedded DSL in Rust, and notes his RE2-style engine lacks backreferences and lookaround.
Guido van Rossum, Python's creator python-ideas mailing list 16 Nov 2017 source ↗
Guido declines to make re.VERBOSE skip all Unicode pattern whitespace, saying Python should not change behaviour simply because it is possible or because Perl 6 has done so.
Matthew Barnett, maintainer of the regex package PyPI project page for regex current release 2026.11.7, read Nov 2026 source ↗
The third-party regex package, an alternative meant to replace Python's re, documents recursive and repeated subpatterns such as (?R) among its added features.
Yukihiro Matsumoto (Matz), Ruby's creator Ruby Feature #4085, Refinements and nested methods, note 42 27 Nov 2010 source ↗
Defending using as the refinements keyword, Matz notes C++ and C# use it for namespaces, knows no language using use that way, and says Perl 6's use mixes in traits as Ruby's include does.
Brent (now Becca) Royal-Gordon, swift-evolution reviewer Swift Forums, [Review] SE-0077: Improved operator declarations, post 5 18 May 2016 source ↗
Reviewing SE-0077, Royal-Gordon says no language other than Perl 6, to their knowledge, has comparably powerful custom operator declarations, via its is tighter, is looser and is equiv traits.
Brent (now Becca) Royal-Gordon, swift-evolution participant Swift Forums, [Pitch] String revision proposal #1, post 14 31 Mar 2017 source ↗
Discussing what to call the string protocol, Royal-Gordon mentions the Stringy role from Perl 6 as a precedent, then recommends StringProtocol.
Don Clugston, D core contributor digitalmars.D newsgroup 19 Feb 2009 source ↗
Clugston recommends Larry Wall's Apocalypse 5, the Perl 6 regex redesign document, to the D community as essential reading.
Rowan Collins, PHP internals participant PHP internals, intersection types RFC thread, message 92870 28 Apr 2016 source ↗
Collins wishes PHP had something like Perl 6's junctions, illustrating with an instanceof test against any(Foo, Bar).
Andrea Faulds, PHP internals contributor, quoting Rowan Collins PHP internals, [RFC] UString thread, message 78213 21 Oct 2014 source ↗
Replying on the UString RFC, Faulds quotes Rowan Collins's point that the internal encoding, possibly something like Perl 6's NFG, should stay invisible to users, and says she agrees.
James Y Knight, python-dev participant python-dev mailing list, PEP 335 discussion 15 Sep 2004 source ↗
In the PEP 335 discussion of overloadable boolean operators, Knight points out that Perl 6 has separate element-wise hyper operators.
Georg Brandl, Python core developer python-dev mailing list 17 Feb 2006 source ↗
Brandl answers a suggested foo(x) -> bar() call-chaining syntax by linking the section of Perl 6's Synopsis 3 on piping operators.
Steven D'Aprano, CPython core developer python-ideas mailing list 31 Oct 2016 source ↗
D'Aprano cites Perl 6's support for Unicode operator symbols as an example in a python-ideas thread.
memoryruins, Rust contributor rust-lang/rust issue #66616, comment 22 Nov 2019 source ↗
Backing a tau constant for Rust, memoryruins notes that Python gained math.tau in 3.6 and that Perl 6 and Nim also provide one.
Stefan Karpinski, Julia co-creator Julia Discourse, Julia motivation: why weren't Numpy, Scipy, Numba good enough?, post 10 23 Feb 2017 source ↗
Karpinski names Dylan as the one other language that treats multiple dispatch almost as seriously as Julia, adding that he has heard Perl 6 does too.

The pattern across these is consistent: when another community cites Raku approvingly, it is for a small, cleanly reasoned semantic detail — string increment, start-exclusive ranges, default rationals, Rat literals, grapheme-level dot, /x by default, assuming, Range matching, chained comparison, dual-precedence and/&&, Whatever placeholders, uncoloured functions — that appears as a row in a survey table rather than as a wholesale design. Core-team members argued from Perl 6 more often than the proposal archives show, but their own proposals died fast: Patrick Walton's -> closures for Rust (2012) and Brad Fitzpatrick's ... statement for Go (2019) were withdrawn within days, on grounds of consistency and tooling rather than provenance. The reasoned rejections are the most useful to an implementer, because each names a real cost: Royal-Gordon's that unrestricted junctions hide loops and their time complexity, Julia's that NFG pays off only for strings that start as UTF-32, and Don Syme's that junction-style comparison can be programmed without language support. PEP 3133 is the strongest evidence that Python's designers read Perl 6 during the Python 3000 period, and Guido van Rossum used it mainly to push PEP 3119 toward a more minimal design (PEP 3133³). PEP 3134 is as close as Python comes to Perl 6 lineage in a shipped feature: its wording places RFC 88 beside Java, Ruby and C# as prior art rather than as the source (PEP 344⁷⁶), but its author's own python-dev message makes Perl 6's @@ the only precedent he found, which stops just short of a borrowing (python-dev²).

What the sources say 1

Ka-Ping Yee, PEP author PEP 344, Exception Chaining and Embedded Tracebacks, Rationale 12 May 2005; superseded by PEP 3134 source ↗
As for other languages, Java and Ruby both discard the original exception when another exception occurs in a catch/rescue or finally/ensure clause. Perl 5 lacks built-in structured exception handling. For Perl 6, RFC number 88 proposes an exception mechanism that implicitly retains chained exceptions in an array named @@. In that RFC, the most recently raised exception is exposed for matching, as in this PEP; also, arbitrary expressions (possibly involving @@) can be evaluated for exception matching.
PEP 3134, which superseded this PEP, keeps the paragraph as it is; the next one turns to C#'s InnerException.