Chapter 5 of 9

Convergent reinvention explains the syntax look-alikes

FeaturePerl 6 dateAdopter and dateWhat the adopter citesVerdict
Heredoc dedent set by the closing delimiterRFC 162 (27 Aug 2000); A2 (3 May 2001); Pugs 6.2.7 (13 Jun 2005); Rakudo 2012.11PHP 7.3 (RFC 16 Sep 2017); Java 15 text blocks (JEP 378); C# 11 raw strings (Swift 4 is in the borrowings table)Nothing; Java cites requests for Swift's or Rust's literals and treats Perl 5 heredocs as rejected prior art; C#'s proposal cites neither Swift nor Perl (PHP RFC1; JEP 3782; JEP 3263; C# 114)Independent (convergent); a Perl 6 → Swift → Java path is possible but undocumented
Ruby <<~sameRuby 2.3 (25 Dec 2015); ticket from 10 Nov 2013Rails strip_heredoc; least-indented-line rule (#90985)Independent
Half-open ranges..^ in A12 (16 Apr 2004)Groovy ..< (proposed 10 Jan 2005, adopted Apr 2005); Swift ..< (23 Jun 2014; Xcode 6 beta 3, Jul 2014); Rust RFC 1192 (Jul 2015); Kotlin ..< 1.7.20 (29 Sep 2022), stable 1.9.0 (6 Jul 2023)Groovy: Ruby's confusable ...; Swift: Groovy, in its own release notes; Kotlin: Swift, Groovy, Ruby, Rust; Rust: Ruby (groovy-dev6; Swift notes7; beta 38; KEEP9; KT-1561310; RFC 119211)Independent; Swift borrowed from Groovy, Kotlin from Swift
Index from end*-1 via Whatever (2006) / WhateverCode (2009)C# 8 ^1 (2019)Nothing; Perl 6 raised by a commenter and dismissed (C# 8 ranges12)Independent (Perl 6 considered)
Implicit lambda parametersRFC 23 (4 Aug 2000); $^a in A3 (2 Oct 2001); $_ in bare blocks, A4 (15 Jan 2002); Whatever-currying in Rakudo 2009-04Groovy it (29 Oct 2003); Scala 2.5 _ + 1 (2 May 2007); Swift $0 (18 Sep 2010); Kotlin it (by Sep 2011); Ruby 2.7 _1 (25 Dec 2019); Ruby 3.4 it (25 Dec 2024)Kotlin: Groovy, per Breslav; Groovy, Scala and Swift: nothing; Ruby: Elixir, Clojure, Kotlin, with Perl invoked only as a readability warning (Groovy c525bfb13; Scala changelog14; Swift 1bef5bd15; Breslav16; #447517; #1898018)Independent; Kotlin borrowed from Groovy
Named-argument punningRFC 84 (10 Aug 2000); :foo() in A12 (16 Apr 2004); Pugs 6.0.14 (4 Apr 2005)Rust RFC 1682 (18 Jul 2016); Ruby 3.1 (25 Dec 2021); PEP 736 (28 Nov 2023, rejected)Haskell NamedFieldPuns, ES6, MoonScript, OCaml, ReasonML; ES2015's own strawman cites symmetry with destructuring and SpiderMonkey's existing {x, y} (RFC 168219; #1457920; PEP 73621; ES strawman22)Independent / common ancestor (ES6)
Keyword-only, positional-only, signature objectsA6 named-only +$x, slurpy *@x (7 Mar 2003); Pugs 6.0.3 (12 Feb 2005)PEP 3102 (22 Apr 2006); PEP 362 (21 Aug 2006, Python 3.3); PEP 570 (20 Jan 2018, Python 3.8)Nothing, except C for / (PEP 310223; PEP 57024)Independent
CLI from a signaturesub MAIN and USAGE in S06 (10 Aug 2006); Rakudo basic MAIN 11 Nov 2008, full 2010.06plac (2 Jun 2010); argh (12 Nov 2010); clize (4 Dec 2011); Fire (15 Feb 2017); Typer (20 Dec 2019); Nim cligenplac: its author's own recipe and annotations; cligen: argh (plac25; cligen26)Independent
Defined-or vs null-coalescingA3 (2 Oct 2001)C# 2.0 ?? (first public in the May 2004 spec; ECMA-334, Jun 2005); Swift ?? (Joe Groff, 26 Jul 2014; Xcode 6 beta 5, Aug 2014); PHP 7 (RFC 6 Sep 2014); Dart 1.12 (31 Aug 2015); JavaScript (TC39); Kotlin ?:C#: no origin statement, and ECMA-334's bibliography names no such language; Swift: nil-coalescing operators in other languages; Kotlin: Groovy and C#, per Breslav; PHP: C#; TC39: Wikipedia (Gunnerson27; ECMA-33428; Swift 0ea3dbc29; Breslav16; PHP RFC30; TC3931)Independent (C# lineage)
Chained comparisonsRFC 25 (4 Aug 2000); A3 (2 Oct 2001); Pugs 6.0.0 (7 Feb 2005)C# proposal, approved 27 Apr 2026, not yet shippedCPL as the earliest design, Icon as Python's inspiration, then Python, Julia, Mathematica, the Lisps, CoffeeScript — and Raku; the meeting notes cite Python (proposal32; LDM 2026-04-2733)Common ancestor (CPL, Icon → Python); Raku cited as prior art
Exact decimal literalsRFC 43 (5 Aug 2000); Rakudo Rat 30 Aug 2009, Int/Int → Rat 31 Aug 2009; decimal literals as Rat in S02 (22 Oct 2009)Pyret exact numbers (TM017); Groovy BigDecimal defaultNothing (Rakudo 9fff15834; TM01735; Groovy36)Independent; Haskell fromRational is an ancestor (Haskell 201037)
Unicode operatorsA3 (2 Oct 2001)Fortress, Julia, Swift; Scala deprecated its Unicode arrows (merged 18 Jan 2019)Nothing (scala#754038)Independent
Runtime role mixinsdoes/but in A12 (16 Apr 2004); Pugs 6.2.10 (10 Oct 2005)Groovy 2.3 withTraits (2014)Nothing (Groovy39)Independent
Optional typing in a dynamic languageRFC 218 (13 Sep 2000); A2 (3 May 2001); A6 (7 Mar 2003)Siek & Taha (2006); PEP 3107 (2 Dec 2006); Dart (Oct 2011); TypeScript 0.8 (1 Oct 2012); Hack (20 Mar 2014); PEP 484 (29 Sep 2014)Thatte, Strongtalk, Common Lisp, Dylan, Cecil, mypy (Siek & Taha40; PEP 48441)Independent / common ancestor
any/allRFC 225 (14 Sep 2000); Pugs 6.0.0 (7 Feb 2005)Python any()/all() (proposed 10 Mar 2005; Python 2.5)ABC's quantifiers, which Guido said they mostly restore (Guido, Artima42)Independent (ABC ancestor); eager reductions, not junctions
Expression interpolationRFCs 222/252 (Sep 2000); "$(expr)" in A2 (3 May 2001); "{ expr }" proposed 20 Jul 2004, in S02 by 14 Aug 2004Swift \( ) (4 May 2012); Scala SIP-11 (2012); ES2015 template literals (strawman Dec 2009); Python f-strings (PEP 498, 2015)Swift: reuse of the escape character; ES2015: E quasi-literals, PHP, Scheme quasiquote, and $ident for Bash, Perl, PHP and Ruby compatibility; Python's lineage: shells, awk, Perl 5, Tcl; PEP 498 names no language (Swift 2f44c0043; swift-evolution44; harmony:quasis45; PEP 21546; PEP 49847)Common ancestor (shell, Perl 5); Swift independent
Typed three-way compare<=>/cmp return the Order enumC++20 <=> (P0515R0, 2017)Perl 5 for the spelling; claims only Haskell returns a type (P0515R048)Perl 5 ancestor; Raku overlooked
What the sources say 48

  1. Thomas Punt, PHP RFC author PHP RFC: Flexible Heredoc and Nowdoc Syntaxes (v0.9) source ↗

    Lets the heredoc closing marker be indented and removes that marker's indentation from every line of the body, for PHP 7.3; no other language is cited.

  2. Jim Laskey, JEP owner (OpenJDK) JEP 378: Text Blocks source ↗

    Defines Java text blocks, which drop incidental leading whitespace with the closing-delimiter line taken into account, and quotes Brian Goetz on requests to copy Swift's or Rust's multi-line literals; Perl is not mentioned.

  3. Jim Laskey, JEP owner (OpenJDK) JEP 326: Raw String Literals (withdrawn) source ↗

    Surveys sixteen languages including Perl, lists Perl's qq{...} among delimiter styles, and describes heredocs as a Unix-shell device that spread to Perl and that many regard as outdated.

  4. C# language design team (csharplang proposal) Raw string literal proposal, C# 11 source ↗

    Specifies triple-quote raw strings whose final line's indentation is removed from every content line, with mismatched indentation an error; the text names no other language, Swift and Perl included.

  5. Prem Sichanugrist (proposer); accepted by Matz Ruby Feature #9098 source ↗

    Asks to bring Rails' String#strip_heredoc into the language; Avdi Grimm suggests the <<~ form, Matz accepts it in November 2015, and no reply in the thread mentions Perl or Raku.

  6. Shijun He, groovy-dev participant groovy-dev, Re: Suggestions for improvement to Groovy source ↗

    Argues Groovy should drop its ambiguous ... range operator and proposes ..<, <.. and <..< for exclusive bounds, with Ruby the only other language he brings up.

  7. Apple's Swift team, internal release notes swift/utils/buildbot-release-notes.txt source ↗

    Logs the half-open range moving to Ruby-style ... in February 2014, a swap in May, then the rename to ..< on 23 June, which the entry says Groovy and other languages already use.

  8. AppDeveloperMagazine, summarising Apple's release notes Report on Xcode 6 beta 3 source ↗

    Reports that Xcode 6 beta 3 respelled Swift's half-open range as ..<, replacing .., so that it reads clearly beside the closed-range ... operator.

  9. Ilya Gorbunov, KEEP author (Kotlin team) Kotlin KEEP: Open-ended ranges and rangeUntil operator source ↗

    Its comparison of other languages' range operators covers Swift's ..<, Ruby's ..., Groovy's ..<, <.. and <..<, and Rust's ..=; Raku's caret forms are absent.

  10. Roman Elizarov, Kotlin team (JetBrains) Kotlin YouTrack KT-15613, Introduce special syntax for the until operator source ↗

    Requests a dedicated operator for Kotlin's until ranges and names Swift's ..< as the requester's preferred model.

  11. Huon Wilson, RFC author Rust RFC 1192, inclusive ranges source ↗

    Proposes a...b for inclusive ranges and remarks that its .. versus ... split reverses Ruby's meaning exactly; Perl is not mentioned.

  12. C# language design team (csharplang proposal) C# 8.0 ranges proposal source ↗

    Introduces ^n to index from the end and an end-exclusive .. range built on Index and Range types, without citing any other language.

  13. James Strachan, Groovy creator apache/groovy commit c525bfb source ↗

    Gives closures an implicit single parameter named it, illustrated with findAll and map over a list; the commit names no source for the idea.

  14. Scala Language Specification (EPFL) Changelog, Changes in Version 2.5 source ↗

    Lists implicit anonymous functions as new in 2.5: underscores in argument positions form a lambda, each underscore a separate parameter, with no source or rationale given.

  15. Chris Lattner, Swift's creator swiftlang/swift commit 1bef5bd source ↗

    Renames anonymous closure arguments from _0, _1 to $0, $1, the message recording that Bertrand favoured the dollar spelling; no reason or precedent is given.

  16. Andrey Breslav, Kotlin lead designer Slides, Shoulders of Giants: Languages Kotlin learned from source ↗

    Credits Groovy for Kotlin's implicit it parameter, attributes the null-safety operators (as?, !!, ?. and ?:) jointly to Groovy and C#, and on other slides credits Java, Scala, C# and Gosu.

  17. jordi polo (proposer); Ruby core team Ruby Feature #4475, default variable name for parameter source ↗

    Requests a default name for a block's parameter; the eight-year thread, closed in 2019 with numbered parameters, cites Elixir's &1 and Clojure's %1 but never Perl or Raku.

  18. Takashi Kokubun (k0kubun), Ruby committer; accepted by Matz Ruby Feature #18980 source ↗

    Proposes it as a name for an unnamed block parameter, discusses Kotlin's it, and draws zverok's warning against adding Perlisms; Matz accepts it for Ruby 3.4 in December 2023.

  19. ranweiler (GitHub), RFC author Rust RFC 1682, field init shorthand source ↗

    Credits Haskell's NamedFieldPuns and ES6 shorthand properties, and weighs a colon-prefixed S { :x } form, attributed to MoonScript, against confusion with Ruby and Elixir symbols.

  20. Shugo Maeda (proposer); Matz Ruby Feature #14579, hash value omission source ↗

    Proposes omitting a hash or keyword-argument value that matches a same-named variable; Matz first objects that it departs from ES6, accepts it in 2021, and Perl comes up only in objections to ES6-style braces.

  21. Joshua Bambrick and Chris Angelico, PEP authors PEP 736, Shorthand syntax for keyword arguments at invocation source ↗

    Several modern languages provide similar features during function invocation, sometimes referred to as 'punning'.

    Before this the section cites Python's own f-string f'{x=}'. The list that follows gives Ruby, ReasonML, SystemVerilog and Jakt at the call site, then OCaml, JavaScript and Rust beyond it; Raku is not among them.

  22. ECMAScript wiki strawman (TC39), last edited by Brendan Eich strawman:object_initialiser_shorthand (Wayback copy, 2 Jul 2011) source ↗

    Proposes abbreviating object literals whose property names equal variable names, mirroring the destructuring shorthand, and cites SpiderMonkey and Rhino already accepting {x, y} in JS 1.8.1.

  23. Talin, PEP author PEP 3102, Keyword-Only Arguments source ↗

    In particular, it enables the declaration of "keyword-only" arguments: arguments that can only be supplied by keyword and which will never be automatically filled in by a positional argument.

    They are declared after a varargs parameter, or after a bare * when the function takes no varargs. The PEP names no other language as a model.

  24. Larry Hastings, Pablo Galindo, Mario Corchero and Eric Vander Weele, PEP authors PEP 570, Python Positional-Only Parameters source ↗

    Users may be surprised when first encountering positional-only notation. This is expected given that it has only recently been documented and it is not possible to use in Python code. For these reasons, this notation is currently an outlier that appears only in CPython APIs developed in C.

    The PEP makes the / marker, until then a documentation convention for C-implemented functions such as pow(), usable in Python 3.8 code. It cites no other language.

  25. Michele Simionato, plac author plac on PyPI source ↗

    Describes plac as deriving a script's command-line options from a function's signature; the earliest release listed, 0.3.0, was uploaded on 2 Jun 2010.

  26. Charles Blake (c-blake), cligen author cligen README source ↗

    Credits Andrey Mikhaylenko's argh, a Python library, as the model for cligen's approach of generating command lines from Nim procedure signatures.

  27. Eric Gunnerson, Microsoft C# team Gunnerson's MSDN blog source ↗

    Announces a revised C# 2.0 specification credited to Anders Hejlsberg, with nullable types as its largest new area, and tells a commenter no change list exists; no origin for ?? is given.

  28. Ecma International ECMA-334 C# Language Specification, 3rd edition, §14.12 source ↗

    Standardises ?? as supplying a fallback for a null nullable value, usable with reference types too; Annex F, the bibliography, cites just C, C++, REXX and ISO 31-0.

  29. Joe Groff, Swift compiler engineer at Apple swiftlang/swift commit 0ea3dbc source ↗

    Adds ?? to the lexer and standard library, describing it only as resembling the null-defaulting operators of other languages, with no language named.

  30. Andrea Faulds, RFC author (patch by Nikita Popov) PHP RFC: Null Coalesce Operator source ↗

    Proposes ?? for PHP 7, mentions C# only to say the precedence matches it, and contains neither a prior-art survey nor any reference to Perl.

  31. Gabriel Isenberg, Daniel Ehrenberg and Daniel Rosenwasser, proposal authors TC39 proposal-nullish-coalescing README source ↗

    Motivates ?? by the pitfalls of || defaults and gives a single prior-art link, to Wikipedia's article on the null coalescing operator.

  32. Cyrus Najmabadi, champion (C# language design team) csharplang proposal: chained relational comparison source ↗

    Lists prior art for comparison chaining: CPL and BCPL, Icon as Python's inspiration, CoffeeScript and Raku, plus math-oriented Python, Julia and Mathematica and several variadic Lisps.

  33. C# Language Design Meeting csharplang meeting notes, LDM-2026-04-27 source ↗

    Approves chained relational comparison unchanged, singles out Python among math-oriented languages as its model, and ranks it fourth of five features for implementation; Raku is not mentioned.

  34. Patrick Michaud, Rakudo lead developer Rakudo commit 9fff158, src/setting/Rat.pm source ↗

    Adds a 47-line first draft of the Rat rational-number type to Rakudo's Perl 6 setting.

  35. Pyret developers (Brown PLT) pyret-lang wiki, design note TM017 Numbers source ↗

    Sketches two separate number types for Pyret, exact arbitrary-precision rationals and approximations written with a tilde, with no automatic conversion between them; it mentions neither Perl nor Raku.

  36. Apache Groovy documentation Groovy Language Documentation, Syntax: decimal literals source ↗

    States that Groovy makes java.math.BigDecimal the default type of decimal literals, for exact decimal arithmetic; the page gives no precedent for the choice.

  37. Haskell 2010 Language Report, ed. Simon Marlow Chapter 6, §6.4.1 Numeric Literals source ↗

    Specifies that a floating literal denotes fromRational applied to an exact Rational, so a literal such as 0.1 stands for an exact fraction before conversion.

  38. Guillaume Martres (smarter), Scala compiler developer scala/scala PR #7540 source ↗

    Deprecates the Unicode arrows ⇒, ← and →, resolving scala-dev#585 and scala/bug#11210, with no reference to any other language.

  39. Apache Groovy documentation Groovy Language Documentation, Object orientation: traits source ↗

    Shows an existing object gaining traits at run time through as or withTraits, which return a new object rather than the original, and states no inspiration for the feature.

  40. Jeremy Siek and Walid Taha Gradual Typing for Functional Languages, Scheme and Functional Programming Workshop source ↗

    Introduces gradual typing, crediting Thatte's quasi-static typing and citing Common Lisp, Dylan, Cecil, Boo, Bigloo and Strongtalk as related optional or partial typing; Perl is not mentioned.

  41. Guido van Rossum, Jukka Lehtosalo and Łukasz Langa, PEP authors PEP 484, Type Hints source ↗

    The proposal is strongly inspired by mypy. … The type system supports unions, generic types, and a special type named Any which is consistent with (i.e. assignable to and from) all types. This latter feature is taken from the idea of gradual typing.

    The lines left out show Sequence[int] as an example of the notation. Other approaches it borrowed from or compares itself with are left to PEP 482; Perl appears nowhere in PEP 484.

  42. Guido van Rossum, Python's creator Artima blog, The fate of reduce() in Python 3000 source ↗

    Proposes short-circuiting any() and all() builtins, used with generator expressions, as replacements for most reduce() uses, and presents them as largely bringing back ABC's quantifiers.

  43. Chris Lattner, Swift's creator swiftlang/swift commit 2f44c00 source ↗

    Implements Swift string interpolation written as a backslash followed by a parenthesised expression, attributing the hardest pieces of the work to Doug Gregor.

  44. Chris Lattner, quoting Jordan Rose (Apple) swift-evolution, thread on replacing the interpolation syntax source ↗

    Endorses Jordan Rose's account that \() reuses the string escape character, its parentheses once mirroring calls to String initialisers, and argues a replacement would force escaping another character such as $.

  45. Mike Samuel's quasi-literal proposal, ECMAScript wiki (TC39) harmony:quasis (Wayback copy, Dec 2011) source ↗

    Chooses backquotes because JavaScript leaves them unused while Perl, PHP, Ruby and Scheme already quote with them, takes ${...} from jQuery templates and PHP, and offers $ident matching Ruby, Bash, Perl and PHP.

  46. Ka-Ping Yee, PEP author PEP 215, String Interpolation (superseded) source ↗

    This document proposes a string interpolation feature for Python to allow easier string formatting. The suggested syntax change is the introduction of a '$' prefix that triggers the special interpretation of the '$' character within a string, in a manner reminiscent to the variable interpolation found in Unix shells, awk, Perl, or Tcl.

  47. Eric V. Smith, PEP author PEP 498, Literal String Interpolation source ↗

    Wikipedia has a good discussion of string interpolation in other programming languages. This feature is implemented in many languages, with a variety of syntaxes and restrictions.

    That is the whole of the section headed “Similar support in other languages”; it names none of them.

  48. Herb Sutter, WG21 paper author P0515R0, Consistent comparison source ↗

    Proposes C++'s <=> with typed ordering results, lists Perl's <=> among existing three-way comparisons, and claims Haskell is the sole major language whose comparison returns an enumeration.

Indentation-stripping heredocs are the clearest case of Perl 6 choosing the industry's eventual answer first, and the one case where the choice demonstrably travelled. Apocalypse 2 accepted RFC 162's option of removing whitespace equal to the terminator's indentation in May 2001 (A249). Swift 4 took that rule from Perl 6 through the SE-0168 authors, as the borrowings section shows; PHP 7.3, Java 15 and C# 11 settled on the same closing-delimiter rule more than fifteen years after A2 without citing Perl 6, even though a 2016 Roslyn comment had put a q:to-style heredoc to the C# team (roslyn #223950). Java's text-block JEP cites requests for Swift's literals, so a Perl 6 → Swift → Java path is possible, but nothing documents it (JEP 3782). Ruby 2.3 used a different, least-indented-line rule taken from Rails (#90985). Perl 5.26's <<~ is the telling hybrid, and it is documented after all: its commit credits nobody, but Matthew Horsfall opened the June 2016 p5p thread by proposing to follow Perl 6's stripping rules and said he had modelled the spelling lightly on Ruby 2.3; p5p then made mismatched indentation fatal where Raku warns and continues, so the rule that shipped is stricter than either source (commit cdd637551; msg23747752; msg23751053; perldiag54). Ranges follow a different shape. Swift's internal release notes record its half-open operator moving from Ruby's ... in February 2014 through a swap in May to ..< on 23 June 2014, which they call precedented in Groovy; Groovy had adopted ..< in April 2005 from Shijun He's proposal of 10 January 2005, which mentions only Ruby, and Kotlin's YouTrack request named Swift as its model (Swift notes7; groovy-dev6; GroovyJSR notes55; KT-1561310). Raku's ..^ (A12, April 2004) is not in that chain. C#, Ruby, Dart and Zig are the languages where Raku's start- and end-exclusive range operators were put in front of the designers and not taken up, and in Rust Perl 6's ..^ served as an argument against using that spelling for the inclusive range (csharplang #18556; #1213357; dart-lang/language #210558; zig#35959; rust#2823760), and Groovy's <..<, the closest functional match to ^..^, appears in the Kotlin KEEP only as Groovy prior art (KEEP9).

What the sources say 12

  1. Larry Wall, Perl 6 designer Apocalypse 2, Bits and Pieces (perl.com) source ↗

    Ruling on RFC 162, Wall picks option (e): each heredoc line loses as much leading whitespace as the terminator carries, counting hard tabs as eight spaces when guessing.

  2. bbarry, non-member commenter dotnet/roslyn issue #2239, comment source ↗

    Offers C# a heredoc idea explicitly taken from Perl 6's quoting docs: a caret-prefixed string whose user-chosen terminator ends a body starting on the next line.

  3. Matthew Horsfall, Perl 5 core developer Perl/perl5 commit cdd6375, Add indented here-docs source ↗

    Adds <<~ heredocs whose closing delimiter may be indented, strips that delimiter's leading whitespace from each line, and makes lines lacking it fatal; the commit credits no source.

  4. Matthew Horsfall, Perl 5 core developer perl5-porters, Indented here docs? source ↗

    Opens the thread with a rough patch for indented heredocs and suggests stripping could follow Perl 6's rules, which he summarises: deeper lines keep their extra indent, shallower ones warn.

  5. Matthew Horsfall, Perl 5 core developer perl5-porters, Re: Indented here docs? source ↗

    Answering Aristotle Pagaltzis's request for the bash and zsh <<- spelling, says he is open to either and based his version loosely on Ruby 2.3's <<~.

  6. Perl 5 documentation (perldiag) pod/perldiag.pod, blead source ↗

    Lists the here-doc indentation-mismatch message under class (F), a fatal error, rather than as a warning.

  7. John Rose, Groovy JSR grammar notes GroovyJSR wiki, 2005/04/01 grammar notes (Wayback copy) source ↗

    Records the switch of right-exclusive range syntax to x..<y, keeping the older x...y legal for a transition period.

  8. Cyrus Najmabadi, Roslyn/C# team dotnet/csharplang issue #185 (ranges), comment source ↗

    Tells commenters that what the caret means in Perl, regular expressions or Fortran has no bearing on the C# design.

  9. Nobuyoshi Nakada (nobu), Ruby core committer Ruby Feature #12133, Ability to exclude start when defining a range source ↗

    Responding to a request for ranges that exclude their start, asks whether Perl 6's neko operator (^..) would serve; Matz does not comment and the ticket is closed unimplemented.

  10. Bob Nystrom, Dart language team dart-lang/language issue #2105 (Ranges in switch cases), comment source ↗

    Surveys range spellings in Perl, Raku (all four caret forms), Ruby, Swift and Rust, then prefers C#-style relational patterns and leans toward deferring range syntax.

  11. ManDeJan, non-member commenter ziglang/zig issue #359, comment source ↗

    Proposes Raku-style carets for Zig switch ranges, such as 0 ..^ 5 or 10 ^..^ 15, linking Raku's Range docs; the issue was closed in January 2021 without adopting them.

  12. Scott Olson, Rust contributor rust-lang/rust issue #28237 (inclusive ranges tracking), comment source ↗

    Objects to spelling Rust's inclusive range ..^ because Perl 6 already uses that operator to mean exclusive, the reverse of the proposal.

Implicit parameters split into three families elsewhere, and none cites Raku. By semantics — this pairing is our analysis, not a claim any source makes — Raku's positional placeholders ($^a) correspond to the numbered-hole family of Swift's $0, Ruby's _1, Elixir's &1 and Clojure's %1; Groovy's, Kotlin's and Ruby 3.4's it, a single named parameter that may be used repeatedly ({ it * it }), corresponds to Raku's $_ in a bare block, whose ancestor is Perl 5's $_ in map and grep; and Scala's _, where each occurrence is a fresh parameter (_ * _ takes two), is the analogue of WhateverCode. The documented origins point elsewhere. James Strachan added it to Groovy on 29 October 2003 with no stated source, and Andrey Breslav's talk on Kotlin's ancestry credits it to Groovy (c525bfb13; Breslav16). Swift's $0 began as _0/_1 in Lattner's July 2010 commit and was renamed on 18 September 2010 because Bertrand, almost certainly Bertrand Serlet, preferred $0 (667078661; 1bef5bd15; Lattner 201962). Scala's _ + 1 arrived in version 2.5 in May 2007 (Scala changelog14), more than five years after $^a and eight months after Whatever entered the spec, but neither the changelog nor the commits up to the v2.5.0 tag give a rationale (scala v2.5.063); Ruby's tickets mention Perl only as a readability warning (#1898018; #1572364). Named-argument punning is the closest miss on the syntax side: Rust RFC 1682 considered a prefix-colon S { :x } form, nearly Raku's :$x, and attributed it to MoonScript (RFC 168219), while PEP 736's prior-art survey covers Ruby, ReasonML, SystemVerilog, Jakt, OCaml, JavaScript and Rust but not Raku (PEP 73621).

What the sources say 4

  1. Chris Lattner, Swift's creator swiftlang/swift commit 6670786 source ↗

    Implements anonymous closure arguments for the language that became Swift, spelled _0, _1 and so on, eleven days after Lattner's initial commit in the public repository.

  2. Chris Lattner, interviewed Podcast transcript on oleb.net source ↗

    Lattner recounts that Swift's 2010 design work began at a whiteboard with Bertrand Serlet, who then ran Apple's software organisation.

  3. scala/scala repository (Martin Odersky and team) Commit history up to the v2.5.0 tag source ↗

    Across the 7,148 commits up to the tag, no message mentions underscore placeholders or where they came from, and Odersky's early-2007 messages give no rationale.

  4. Stefan Schüßler (proposer); Benoit Daloze, Ruby core committer Ruby Feature #15723, Reconsider numbered parameters source ↗

    Argues numbered block parameters make code harder to read and recalls Ruby already discourages Perl-style $ variables; Benoit Daloze later says he does not want Ruby's readability sliding toward Perl's.

Signatures and CLIs show how timing alone misleads. PEP 3102 added keyword-only arguments in April 2006, three years after A6 and a year before PEP 3133 proved that Python 3000 designers were reading Perl 6; yet it names no other language (PEP 310223), and the python-3000 threads that produced it settle the question. Their only Perl 6 remark is Guido's dismissal of a bracketed parameter syntax as emulating Perl 6, a day before he pronounced the bare *; nobody mentioned A6's named-only parameters, and the later PEP 3102 threads name no other language at all, so the verdict is independent invention (00109465; 00115066; python-dev67). Rakudo shipped MAIN and USAGE in its 2010.06 release (Rakudo ChangeLog68); Michele Simionato's plac, which also generates a command line from a function signature, reached PyPI on 2 June 2010 — the same month (plac25), and every later tool in that line, through argh, clize, Fire, Typer and Nim's cligen, descends from the Python side (cligen26). On paper Perl 6 was four years ahead: Larry Wall specified MAIN, multi-dispatch over MAIN candidates, signature-generated usage text and a USAGE override in one S06 commit on 10 August 2006, crediting only Unix switch conventions and Perl 5's unless caller idiom, and Rakudo ran a basic MAIN from 11 November 2008 (msg2579569; 41d13f870). Both requests to copy it that turned up were refused: Ruby's developer meeting rejected a Perl 6-like main in July 2012, and Go's Brad Fitzpatrick declined one in 2016 (#501171; go#1717872).

What the sources say 8

  1. Guido van Rossum, Python BDFL python-3000, Type Expressions thread source ↗

    Dismisses proposed bracket notation for special parameter lists, telling the list that Python should not be copying Perl 6; no one in the thread had brought up Perl 6 before.

  2. Guido van Rossum, Python BDFL python-3000 mailing list source ↗

    Pronounces that a bare * in a parameter list makes the parameters after it keyword-only, to head off further unusual notations.

  3. Talin, PEP 3102 author python-dev, PEP 3102: Keyword-only arguments source ↗

    Posts the draft PEP 3102 to python-dev, opening a 62-message thread in which no other language, Perl included, is named as a precedent.

  4. Rakudo development team Rakudo docs/ChangeLog, releases 2009-04 (#16) and 2011.09 source ↗

    Notes in the 2009-04 release that a method call on the Whatever star now builds a closure, and lists :D and :U type modifiers among the additions in 2011.09.

  5. Larry Wall, Perl 6 designer perl6-language, S06 commit mail (svn r10804) source ↗

    Adds S06's MAIN section: Unix-style switches map to MAIN's named parameters, multi MAIN candidates dispatch, a dispatch failure invokes USAGE or a generated message, and the direct-run rule is compared with Perl 5's unless caller.

  6. Jonathan Worthington, Rakudo developer Rakudo commit 41d13f8 (Parrot languages/perl6, r32554) source ↗

    Adds rudimentary support for a MAIN sub as the program's entry point, which at this stage hands every command-line argument over as a positional.

  7. Yusuke Endoh (mame), relaying the Ruby developer meeting Ruby Feature #5011, note 7 source ↗

    Reports that the 21 July developer meeting rejected the Perl 6-like main proposal; Matz felt improving optparse was worthwhile but this proposal pointed the wrong way.

  8. Brad Fitzpatrick, Go team golang/go issue #17178 source ↗

    A user asks for main() parameters bound to command-line arguments as in Perl 6, citing the 2010 Advent post; Fitzpatrick closes it within the hour, saying Go 2 will not take every language's features.

Gradual typing is where Perl 6 came closest to acknowledgement and still received none. Jeremy Siek's explainer names Perl 6 alongside Python 3k and ES4 as languages gradual typing should give a foundation to (Siek73), but the 2006 Siek & Taha paper itself mentions Common Lisp, Dylan, Cecil, Bigloo, Strongtalk and Thatte, not Perl (Siek & Taha40). Perl 6's model — annotations add checked constraints and an unannotated variable means Any — is closer to Common Lisp-style optional typing than to Siek's sound-at-the-boundary gradual typing, so Wikipedia's uncited claim that Raku had gradual typing from the start is true only in the loose sense (Wikipedia: Gradual typing74). The P0515 survey for C++20's <=> is a small but telling data point: it asserts that among major languages only Haskell returns a type from three-way comparison, overlooking Raku's Order enum (P0515R048), which fits the broader finding that designers' surveys rarely look at Raku at all.

What the sources say 2

  1. Jeremy Siek What is Gradual Typing (explainer) source ↗

    Names Dylan, Cecil, Common Lisp and others as having optional annotations, and lists Perl 6 with Python 3k and ECMAScript 4 among new languages that gradual typing aims to underpin.

  2. Wikipedia Gradual typing article source ↗

    Claims, with no footnote, that Raku supported gradual typing from its beginning, and credits Siek and Taha with naming and developing the idea in 2006.