` optimization [deac603] + Fixed .split(...:skip-empty) not skipping with empty strings [fc86084] + Fixed duplicated .done/.quit on Channels in Proc::Async on exit [c4a4c84] + Fixed error handling when Proc::Async process failed to spawn [f73d984] + Made sure `infix:` always returns a Seq [1eb7b1f] + Partially fixed `infix:` being non-lazy [f190f24] + Fixed SC collision when loading identical modules from different dists [254f76a] + Fixed CURI loading of modules with identical short-names [c1a0fa7] + Fixed SEGV in exception handler resolution in sub/INIT/return [b2eb115] + Fixed SEGV on `xx` with a huge repeat values [1cafc67] + Fixed SEGV on chars with a huge number of combiners [1cafc67] + Fixed SEGV when `Scalar` type object is processed by `unique` [cfe0e04] + Fixed .comb(Int) failing to work on Cool [a08e953] + Fixed hang in dispatch of .lines/.words when given wrong args [7425737] + Fixed cases of lack of panic upon with quantifiers in regexes [91a4ac5] + Fixed broken thunking of infix: [5e6f30a] + Fixed failure to thunk RHS on `or=`, `and=`, and `notandthen=` [3e88c41] + Fixed precision loss with `cmp` involving Rationals/Int [9e8ecb7] + Fixed crash in .Bool, .so, .not, .hash, and .elems on Baggy:U [e8af855] + Fixed crash in .Str on Bool:U [3de5fb2] + Fixed crash in IO::Special .WHICH/.Str [dd4dfb1] + Fixed install wrapper when no binaries are found [796b6a8] + Fixed crash when calling .sort on reified empty Array [8e250db][75e070f] + Fixed `Nil` being displayed as `Mu` in REPL [a274bdd][cd47e2a] + Fixed previous output silencing exceptions in REPL [db70a1f][61a65ce][7f9235c] + Fixed loss of data when using a hash in assignment to itself [ae7bcf1] + Fixed IO::Path.e failing to detect changes on the filesystem [76f7187] + Fixed `infix:` with Seq/List containing same elements [f9eb811] + Fixed CArray to pass NULL when for type object elements [26e6993] + Fixed GC deadlock when event loop worker thread was spawned [26e6993] + Fixed `:i` in regexes using lowercase instead of fold case [26e6993] + Fixed parsing issue with detached methods in `[…]` metaop [e1ebb50] + Fixed unwanted list flattening in triangle reduce [10f5f74] + Fixed Range.int-bounds for NaN and Inf end points [79f2681][16ef21c] + JVM backend fixes [b1def95][2f6d2c6][dc19892][cef41b2] + Various improvements to error reporting [dc5fb20][d66c382][b11dc88][6cb9be2][3bf734f][26e6993] [20fa14b][127338a][1934a56][27dc7b1][1e24666] + Additions: + Made symbol imports of `require`d modules lexical. For more information, see http://rakudo.org/2017/03/18/lexical-require-upgrade-info/ [63cf5ca][3e86d0f][5b98caa][6771dee][9da6de4][4fce405][030c4c5] + Added ≤, ≥, ≠ as Unicode versions of <=, >=, and != [5c68ea6] + Made it possible to hyper ops that return a Seq [e2db7b8] + Made `infix:<∘>` keep RHS's .count and .arity and LHS's .of [032b283][cb149a8] + Made purity propagate up through meta-meta ASTs [68a40f7] + Made Proc::Async default to translating newlines [05add43][2973ccd] + Implemented Str.parse-names [5c1761a] + Added `$epsilon` argument to Complex.Rat/.FatRat [a4af702] + Fixed loss of precision in Instant.Rat [a4af702] + Implemented .FatRat coercer in Cool and Numeric [a4af702] + Added Mu candidate for `infix:` [e270a15] + Implemented Mu.iterator [81fcd1b] + Made sure Str.split always returns a Seq [f595733][8301a30] + Made List.reverse return a Seq [beda576] + [EXPERIMENTAL] Added support for Parameter.set_default [d6c95ea] + Implemented new internal braids API to make future optimizations easier. This affects any slang modules that access `%*LANG`, `%*PRAGMAS`, and `$*ACTIONS` internals using unofficial API. + Removals: + Removed IO::Path.Bridge [212cc8a] + Removed support for IO::Handle.lines(:close) agument [76a59cf] + Efficiency: + Made min/max/min=/max= about 3x faster [a9c5196] + Made .WHICH of numerous types about 1.8x faster [79bb179][65b0040] + Made case-insensitive regex match 20%-30% faster [5b6e0fb][f73d984] + Made triangle reduce right op with 2 params 2x faster [e114d52] + Made triangle reduce right op with 2+ params 1.5x faster [d04c47f] + Made IO::Handle.lines about 10% faster [9019a5b] + Made IO::Handle.getc about 3% faster [9019a5b] + Made reduce chain op about 5% faster [9cec31a] + Made IO::Handle.lines about 10% faster [9da50e3] + Made List.reverse 0%–30% faster and reduced memory pressure by up to 70% [beda576] + Made loops/maps with NEXT phaser about 5% faster [80e0bce] + Made `infix:<%%>` about 14x faster for Int,Int case [755e25b] + Made `infix:<%>` about 8x faster for Int,Int case [5ec2517] + Made Junction creation about 20% faster [fafe663] + Made callframe() about 20% faster [7966dad][9a74cd0] + Made meta reduce with right-assoc. op 30%–200% faster [60a8f9e][2cf9b53] + REMOVED caching of IO::Path.e results to fix unwanted behaviour [76f7187] + Assorted internal improvements to CPU/memory use [b2e0ac0][25a3cc5][b61b3c7][829762a][45b3af8][7010ae9][556db9d][9e9a4ad] [8e8cd14][7556498][adb6f87][9a109c9][3de7b08][b283e52][0be7247][74573d0] [79d5670][313e7b2][e723e00][5843ee6][7c279c3][318f8ee][4ef1e69][9d497e9] [b597398][4bc826d][9da50e3][2a2e460][0633f03][d444f65][f94a2c7] New in 2017.02 + 6.d.PREVIEW changes: + It is now possible to use different language versions in different comp units. Pragma `use v6.d.PREVIEW;` loads PREVIEW version of 6.d language [9044fca] + Made `await` non-blocking (i.e. not using a thread for waiting) [dd1cb5f] + Made `react` non-blocking [4aa8d70] + Various improvements to error reporting [ee7c1bb][a2d69a0][f22170f] + Fixes: + Fixed data race in NFA cache [8f53a6f] + Fixed handling of Unicode characters on Windows command line [8f53a6f] + Fixed overflow during full GC collection on 32-bit systems [8f53a6f] + Fixed GC problem in string repeat op [8f53a6f] + Fixed .perl.EVAL roundtripping for circular Arrays and Hashes [67aeefa][673f06b] + Fixed instantiation of subclasses of classes that do Rational [7f245f7] + Fixed incorrect handling of precision flag in sprintf '%d' [a1c7d01] + Fixed `infix:(..., *)` for empty Slips [4e49ec1] + Fixed .pairs, .values, and .kv with native shaped arrays not having values in writable containers [0fdb9e4][1181afe][e195e5f] + Changed Pair.AT-KEY on non-existent key to return Nil [9728c4a] + Fixed Slip.List not returning a Slip instead of a List [4d4822a] + Made Map.List and Hash.List always return a List [6dd542f] + Fixed crash when using `.=` to initialize attributes [700a077] + Fixed leak of asynchronous task handles [483e4fd] + Fixed issues in .skip-one in internal Mappy iterator [3a77cb5][e7ea4c2] + Fixed count-only on all Hash based .kv methods reporting only half of actual value [aecbb3e] + Fixed crash in internal iterator used by .rotor and .batch [bcd902a] + Fixed LAST phaser called twice in sunk do for {} loops [3424465] + Fixed various discrepancies as a result of inlining non-native types [f8b3469] + Fixed leaks and an invalid read in synchronous sockets on errors [9ed4449] + Fixed NFA generation for the constructs `x ** 1..2` and `:i <[A..Z]>`, and hardened NFA processing in MoarVM so as to not read out of bounds [9ed4449] + Fixed memory leaks on startup and module load with augmented types [9ed4449] + Fixed smartmatch of Complex against Ranges [f2894d3] + Fixed premature overflow of `div` on native int types [c98b3a5] + Fixed flat()/Iterable.flat not propagating `is-lazy` [51b0aba][ca102c5] + Fixed hang with `*@` slurpies when given infinite list [51b0aba] + Fixed abs() failing with negative zeros [f85978b] + Fixed List.perl of containerized empty lists [a148c70] + Fixed at-times incorrect result of Rational.ceiling [6372417][79553d0] + Fixed Rational.norm failing to normalize the Rational [aac9efc] + Fixed issues with close() and read() on closed async sockes [f16cf37] + Fixed occasional disordering of messages in Supplier::Preserving [cabf6fb] + Fixed a data race in NFA caching causing SEGV [62bd30b] + Fixed data races and over-sharing of %*ENV in precompilation [bab1c02] + Fixed data races in CompUnit::PrecompilationStore::File [accc156][39c517e][917d473][a88da2e][6c374d5][2b1eb64] + Various improvements to error reporting [10bcec2][5822605][f230224][b51a550] [8733aa5][483e4fd][f0b9234][e922275][51ebfb1][acae345][1b99196][301bcf9] + Additions: + Implemented Array.clone [dc69daf] + Implemented Mu:U.clone [11d005e][4b85db6] + Added experimental `infix:` [6f6f0cf][5870ef9][eb3356c][6990133] + Added experimental `infix:`, `Any.collate`, and `$*COLLATION` [2061485][4efcc29][46313fa][1923878][5611425][6990133][f85978b] + Implemented Any.skip [8a6bfc6] + Implemented Supply.skip [d71bf1e][15753fd] + Implemented Any.batch [e0201f1][f6531d3] + Added Supply.rotor($batch) candidate [5694727] + Added support for all Nd characers in sprintf format strings [483e4fd] + Added support for more named Unicode sequences [3a77406] + Made named Unicode lookups (e.g. "\c[...]") case insensitive [3a77406] + Added support for Support East_Asian_Width Unicode property [9ed4449] + Made CompUnitHandle.globalish-package return the actual Stash [960a789] + Made Test.pm6's skip() only accept Int test counts [ae9d517] + Numerious fixes related to colonpair-extended names on subroutines [48abeee] + Made merging of Perl 5 symbols use the same mechanism as for Perl 6 [4e7ab20] + Included try-load in CompUnit::PrecompilationRepository's interface [d932355] + Made S/// set $/ to Match objects made during substitution and avoid returning the result in $/ causing container-reuse in loops [97359ae] + Made CompUnit::Repository::Installation sort binaries by version [7c39bbf] + Made it possible to call IO::Path.s on a directory [25fd1ca] + Gave fakesignature a $/, $_, and $! to avoid unintended sharing [71a1283] + Implemented smartmatch of character Ranges [8477f3b] + Str ~~ Numeric no longer throws if Str cannot be coerced to Numeric [1615c83] + Efficiency: + Made SetHash.iterator|pairs|antipairs|kv|values about 20x faster [a2fbe20] + Made Int.WHICH about 1.7x faster [9841313] + Made Baggy.kv about 15% faster [e995107] + Made Baggy.kxxv about 30% faster [5db0b29] + Made Baggy.antipairs about 25% faster [2922ec4] + Sped up postincrement and postdecrement by about 5% [fd74c91] + Internal improvements for 1%+ faster parsing [dd514da][9493ffb][951a441] + Made `` parsing 5%+ faster [0bb7c20][d5262e6] + Generalized sink branch optimize logic improving performance for sunk post increment [5401a1a] + Improved radix operations (50% faster with non-ASCII digits) [9ed4449][c98b3a5] + Made uniprop/unival/unimatch 1.1x to 2.1x faster [411782e] + Fixed performance loss on `infix:` with very large number [8878af8] + Made Map.sort about 1.5x faster (also affecting its .perl/.gist/.Str) [0ee3b7d] + Made an improvement in candidate selection order of &sort [b7c6e73] + Made .skip of internal mappy iterator about 15% faster [54f647d] + Made List.keys on lazy lists a bit faster [0ad05ce] + Made Seq.InfiniteLoopIter about 6% faster [00e60d9] + Made do repeat while about 3%-11% faster [a832944][af49026] + Made `do while foo { bar }` loops about 20% faster [4932112] + Made `do repeat while foo { bar }` about 20% faster [3888b42] + Made `do loop ( init; while; next ) { }` loops about 6% faster [c2eb7fb] + Made `.map: -> $_ --> non-Slippy-Foo { ... }` maps about 2x faster [fdcf462] + Made firing of phasers about 25% faster [7e98504] + Made `my @a = do for @b { ...; PHASER foo }` about 1.5x faster [031efe0][3424465] + Made `for @b { ...; PHASER foo }` about 15% faster [031efe0] + Made `@b = @a.map: { }` 10% and `@b = do for @a { }` 20% faster [3e28b1e] + Made `for @a { ... }` about 1% faster [d69f375] + Made `my @b = @a.map: -> \a,\b { }` about 15% faster [9f15a4d] + Made `for @a -> \a, \b { }` about 2% faster [7384939] + Made .tail on reified List/Array about 8x as fast as `[*-1]` and .tail(N) about 16x as fast as `[*-N .. *-1] [*-N .. *-1]` [833fe43] + Made improvements and refactoring of various internal iterators [f2b97b0][18e6f0d][87f61d9][c069f45][ad90806][4ef37cf][54f647d][49e2d40a] [7c26985][4d8fc05][b1afc13][072d959][9d5c3fd][6b6a0b4][b31c591][b9d9279] [f799a03][98f9d8a] + Made improvements to performance of internals [ed4ef3b][f85978b] New in 2017.01 + Fixes: + Fixed importing globals nested in imported packages [85d8b14] + Fixed "Object of type A in QAST::Var value, but not in SC" [43d20eb] + Fixed use Foo::Bar; class Foo {my Foo::Bar $bar} not finding Foo::Bar [5c4db5e] + Fixed class Foo { use Foo::Bar; my Foo $foo; } not finding Foo [226cb36] + Fixed our scoped nested package swallowed by lexically scoped parent [85b9d8a] + Fixed imported nested enum colliding with symbols from outer scope [a962928] + Multiple methods that return listy things now throw instead of failing to avoid accidental Failure silencing through 1-elem lists [99e33fc][bd4e1f4] + Made List.roll always return a Seq [bd4e1f4] + Fixed SEGVs and GC panics in certain deep recursions [58c79e2] + Fixed detection of runtime errors in threads [b8df3a6] + Made sure .sort on shaped arrays uses the leaves [a4bc51a] + Made U+2212 infix:<−> and prefix:<−> same as regular `-` for all types [91af128] + Made sub MAIN usage ignore anon *% param [38ec79c] + Fixed lack of warning on unitilized values in infix: [c498d5b] + Fixed Distribution::Path bin/resources file format [393afcf] + Fixed spurious warnings in List.reduce [1ee24cc] + Sorting uninitialized List now returns a new list [005166e] + Made .sort always return a .Seq [434bf75] + Fixed combinations() incorrectly returning 1-item list in some cases [d86c419] + Made combinations() always return a Seq on succcess [db1836a] + Fixed useless "useless use" warnings in hypered ++ and -- [7193df1] + Fixed numerous bugs with $limit in lines() [19df358] + Fixed regression with mutability of .pairs on shaped arrays [dc7b688] + Fixed regression with infinite lists assignment to shaped arrays [aa35065] + Fixed regression with looping over uninitialized shaped array [696b1f4] + Fixed regression with regex match against NFC [8d35951] + Fixed infix: with 0-denominator rationals [a567eb4] + Fixed crashes in X::OutOfRange reporting with 0-denominator rationals [b2332c2] + Fixed &infix:<==> on 0-denominator rationals [73182d4] + Fixed &infix:<===> on 0-denominator rationals [cb2476f] + Fixed incorrect .isNaN result for 0/0 rationals [7434a8f] + Fixed IO::Socket::INET.new not parsing IPv6 URLs correctly [cb9ec03][df20d8b][fbd061b][8751f05] + Made IO::Socket::INET.new fail when invalid port or family is given [cb9ec03] + Fixed Range.AT-POS on int ranges failing for too-high indexes [c5e54ef] + Fixed (^) set operator on Baggies to take weights into account [a687d95] + Fixed incorrect dispatch in some cases of multi subs with where clauses [0c0dd82] + Fixed unwanted role punning due to attached Pod [d487657] + Made Routine.prec(key) return '' rather than Nil on fail [d7d76b7] + Moved .prec from Routine to Code [a7ccfc6] + Fixed an occasional heap profiler crash, and prevent heap profiler from greatly reducing the number of full GC collections [e182deb] + Fixed specializer log slots keeping alive, and so leaking, objects once specialized code has been produced [e182deb] + Fixed build under some versions of MSVC [e182deb] + Fixed code-gen bug in dispatch: [3d86286][ba8a284] + Fixed `1,*,3 Z~ ` case using Whatever value for the rest of list [471f4ba] + Fixed threading issues in ||=, //=, and &&= [d1c2e76] + Fixed GC in spesh triggered by managed mutex use [25615c7] + Fixed bugs in interaction between inlining, GC, and threads [25615c7] + Fixed endpoint-exclusion on string ranges with non-alphanumeric chars [daf7e51] + Fixed fatality of Nil.chomp/chop (back to just a warning) [7c81bec] + Fixed infix: on NaN and signed zeros [3f80e13] + Fixed crash in infix: when comparing Real and RatStr [8ec54ba] + [TEST] Test.pm tests no longer backslash every backslash in descriptions [b183cab] + [TEST] Fixed TAP::Harness parsing of single backslashes in test descriptions [b120ac4] + [TEST] Fixed TAP::Harness failing to parse full-file skip directive [aee7af3] + [UNI] Fixed `ISO_Comment` property in uniprop [4ff2fb2] + [UNI] Fixed uniname() on "\x[80]", "\0" and other controls [8163113] + [UNI] Made unival() use full Unicode names for Numeric_Value_* [dbbf9dd] + [UNI] Fixed several aliases for Unicode characters [5ba982a][644cd34] + [UNI] Fixed number of characters reported for hundreds of Unicode Emoji [823f0f7] + [UNI] Fixed compilation of /:ignoremark \"/ to actually ignore marks [6188771] + [UNI] Fixed mismatched closers on U+298D/U+2990/U+298E/U+298F brackets [76283f6] + [UNI] Fixed return value of uniprop Bidi_Mirroring_Glyph if no BMG [48e8ccc] + [UNI] Fixed breaking after Prepend characters [7c8b705] + [JVM] Fixed build issues [7bba13a][adcfb8b][e6ccb47][29f487e] [fb4f161][4320fdc][39bf63f] + Assorted improvements in error reporting + Additions: + Made importing globals from loaded modules lexical [4b529c8] + Added degenerate Any.match [3fe5893][cc0f836] + Added infix +/- for DateTime/Duration [6b850ba] + parse-base() now allows for omitted whole part [3282813] + Using a Bool:D literal as type constraint in signatures now warns [b01dfcd] + Made Bool.ACCEPTS work with Junctions [9fc616f] + Made Proc::Async sub-class friendly [a2cc58a][1dc0c01] + Implemented .clone for SetHash, BagHash, and MixHash [1ee9c82] + Implemented .List on shaped arrays [8568dd1] + Added own .perl method to Empty [ec0258a] + Made Inf and Whatever work as part of rotor()'s cycle [7ddc5f7] + Made it possible to use Inf and Whatever in .head and .tail [93b0ffa] + Implemented `next` in `whenever` blocks [f97d5c2] + [TEST] Test::is() now handles Mu types [268dc92] + [UNI] uniprop now handles Emoji properties [3baffe7] + [UNI] Implemented Bidi_Mirroring_Glyph as an integer property [7c8b705] + [UNI] Implemented Emoji grapheme breaking and other combined codes [7c8b705] + [UNI] Added Emoji Unicode properties [7c8b705] + [UNI] Added secondary and tertiary Unicode collation support [ee38721] + [UNI] Re-implemented UTF8-C8 streaming decode [7c8b705][ee38721][e182deb] + [UNI] Made all Nd chars accepted in ${} special variables [eba3fe0] + [UNI] Made all Nd chars accepted as regex quantifiers [e40a129] + Removals: + [UNI] Unicode 1 character names are now deprecated and issue a warning [e7c1d51] + Removed IO::Path:U.chdir candidate on account of it being a footgun [94df18c] + Efficiency: + [UNI] Made unival() slightly faster for repeated lookups [dbbf9dd] + [UNI] Made decoding UTF-8 text 14% faster [528ec53] + Made compilation of custom operators about 1.5x faster [c99fbc6] + Made improvements to memory management of various aspects of invocation records (aka call frames), greatly reducing memory pressure in a number of cases, especially in applications that produce and store a large number of closures. Up to 20% improvement to CORE.setting build time and ~10% peak memory use reduction observed [e182deb] + Made I/O memory buffers properly contribute to full collection criteria, reducing memory overhead required [e182deb] + Made @a[*-1] 13% faster [b39c0d8][ab26b58] + Removed unnecessary caching on .elems in core code [ab26b58] + perl6 -ne '' is now about 40% faster [541d127] + Made IO::ArgFiles.lines about 10% faster [73797b7] + Made List.sort() about 4x faster [8d33b89] + Made native @a.sort() about 12x faster [4b2cea0] + Made Str.split() about 3x faster [f0398fb] and then 10%-40% faster on top of that, based on length of string [2496963] + Made Any.sort(&by) about 40% faster [1374fcf][def5262] + Made List.sort(&by) about 5% faster on reified List/Array [1e54371] + Made .sort on 0- and 1-element lists 10%-40% faster [340bc90] + Made .sort on 2-element lists about 50% faster [4724bd6] + Made Supply.sort a multi for faster dispatch [54cc06b] + Made Cursor.MATCH about 10-15% faster [9eef565] + Made QuantHash.AT-POS and Baggy.new about 5%-8% faster [c13e67b] + Made is nodal check a bit faster [0f25d83][996ab6a] + Made Capture.Bool about 3x faster [516e527] + Made sorting of 0,1,2 element native arrays about 30% faster [4038c6c] + Made generating iterator after List.eager does not reify again [7a759d7] + Added Seq.join that's 25% faster than List.join [3c52aa0] + Make @a Z @a 5x faster [4ab020f][3d1d699] + Made slow-path in grep 10% faster [362f674] + Made fast-path in grep about 1.4x slower as a result of a bug fix [362f674] + Made internal improvements with Empty and SlippyIterator [ebe9147] + Streamlined .prec on operators [caba0d3] + Made zip(@a,@b,:with(&[+|~]) about 12x faster [62f7027] + Made zip(@a,@b,:with(&op)) about 7x faster [62f7027] + Made zip with generic listinfix ops (e.g. zip(@a,@a,:with(&[minmax])) about 2x as fast [5c685f2] + Made zip(@a,@a,:with(&[=>])) about 5x faster [46cdf16] + Made generic right-assoc zip ops in zip(@a,@a,:with(...)) form at least 2x faster [6703b4c] + Made Zop handling (except for non-LHS-thunky ops) 13x faster [f66d4b3] + Made List.from-iterator about 10% faster [8f3476d] + Streamlined Array.from-iterator, making it 30% faster in some cases [fab1a14] + Improved ||=, //=, and &&= by avoiding thunking and invocation [d1c2e76] + Made List.combinations(N) about 20% faster [1a54bba] and on top of that made List.combinations() 1.5x, List.combinations(3..5) 2x faster [502fc77] + Made permutations() 2x to 24x faster [78edbbb][b5293c2][c64aeb3] + Made roundrobin() about 4x faster [73d0cec] + Made X and cross(...,:with) about 5x faster [8a3ff7b] + Made Xop about 7x faster [a26f513] + Made 1 X foo about 20% faster [d4a5b69] + Made List.rotor between 15x and 20x faster [d7b8214] + Made Range.excludes-(min|max|infinite|is-int) 2.5x as fast [99b186b] + Made reified List.Array about 3x faster [c9a9bc8] + Made List/Array.sum about 30% faster [017c6cf] + Made List/Array.fmt with no args about 60x faster [22e589a] + Made List/Array.fmt("%s") about 60x faster [7ef3682] + Made List/Array.join about 20% faster [ed482ec] New in 2016.12 + Fixes: + Fixed inability to autocurry superscript exponents properly [c35d562] + Fixed Match.prematch and Match.postmatch for zero-width matches [c04b8b5] + Fixed Match objects being erroneously treated as value types [7f26e8b] + Made U+2212 minus work in places it didn't [cb9df2b][01775b7][6cd2144] + prefix:<~> now calls .Str on Str types (helps with allomorphs) [e0a415f] + Fixed errors in `$*ARGFILES.lines` limit counter [bd42363] + Fixed bug with add history for Readline module in REPL [f544e4c] + sum and [+] metaop now correctly work on Junctions [8d04bec] + Fixed various scoping bugs with NEXT/LAST/QUIT [6bb8823] + Fixed issues in QUIT handlers running asynchronously [c027e6a] + Fixed occassional hangs in Proc::Async [e4d78c6] + Fixed operations still running after supply deactivation [f928a20] + Fixed Iterator.flat occasionally skipping inner iterables [61a18c0] + Fixed slurp not propagating :bin and :enc args on `$*ARGFILES` [15f51a5] + Fixed negative zero handling in many places [f1263ab][e2587cd][a9654c0][085145f] + Synthetics in numbers in colonpairs in :42foo format now throw [4663d43] + Fixed hang in .subst with no arguments [0a874fb] + Fixed sleep() with huge values failing to sleep [c797d3f][7c5ea31][2f72fa0] + Fixed attributive binding not looking outward for `self` [843a6be] + Fixed sprintf($format) without args issuing spurious warnings [35183f3] + Fixed infix:<===> failing when both sides are allomorphs [4a59ab4] + Fixed data race in Supply.interval [47ffdea] + Fixed data races in supply/whenever [33f7456] + Fixed memory corruption in Proc::Async [74eb6b9] + Fixed handling of time resolutions below 1ms in Supply.interval [c38f1ad] + Fixed issues with `-Inf` being a single term [ae614f9] + Fixed Signature.gist stripping sigils from anon typeless scalars [219f527] + Made permutations/combinations/grep die instead of fail()ing [ab3a59c][bc13bb5] + Fixed spurious warnings on .trans with regex pair complements [2e1b82c] + Fixed premature frees in async sockets when errors occur [b2ac4e4] + Fixed handling of superscript powers larger than int [0428b79] + Fixed Proc::Async sending empty string to taps on program exit [7532297] + Fixed wrong results for .first on Numerics [8cb3e1b] + Fixed matcher-less .first not respecting its adverbs [ababb24] + Fixed `sink` statement prefix failing to explode Failures [345f6a7] + Fixed regression in S:g/// not returning original string [5476d60] + Reverted .match/.comb to return empty List instead of Empty when failing to match [5476d60] + Fixed Mu.clone incorrectly marking all attributes as initialized [9a161fa] + Fixed cloned Baggy having an undefined .WHICH [9a161fa] + Fixed smartmatching against UInt type object [f9d34a9] + Fixed some Date constructors accepting invalid dates [aa27d5c] + Fixed .rotor on empty list returning an internal iterator object [5558710] + Fixed unimatch to check canonical short/alternate unicode props [b456471] + Fixed uniprop to return correct values for na, uc, tc, lc properties [2a8ec40] + Fixed uniprop for 'Numeric_Value' not returning a numeric value [9ff5b7e] + Fixed crash with Rat Ranges constructed with Range ops [1d46004] + Fixed crash with tapping supplies supplied by thunked block [a980eb1] + Fixed .perl on parametarized Hashes with no items in them [003e654] + Fixed .perl for itemized Slips [8eef234] + Fixed chained `andthen`/`orelse` operators returning internals [287af6a] + Fixed ThreadPoolScheduler.cue not applying delays to all cues [b286048] + Fixed control exception propagation when thrown from within statements handled by `without`, `with`, `andthen`, or `noandthen [9a3c350] + Fixed Rand.rand generating value equal to excluded end point [334d134] + Fixed `last` not working inside .grep's block [7021861][f775474] + Fixed .head not always returning a .Seq [69d808f] + Various fixes and improvements in error reporting + Additions: + Bare \b, \B, and \K in regexes now throw [08589d3][ee14067] + Added SQL as an output option for --profile-filename [f20b8b6] + Implemented native str Arrays [014d4cf][6d726f8] + sub MAIN now allows Enums as type constraints [546dbd9] + Count in .pick/pickpairs/grab/grabpairs can now be a Callable [e9487d6] + REPL with Readline module now loads `inputrc` files [573ed59] + REPL with Readline module now saves history [9043f58] + perl6 --doc=Text now shows signature parameter pod [6ea6563] + Generated sub MAIN usage message now shows original program name [b597b7c] + Added arity-1 infix:<~> for Blobs [77e9d4b] + Added IO::Handle.printf [8774f24][3c4ac3c] + Added ability to negate all numeric literals in signatures [5baa064] + Added .reverse/.rotate/.sum to shaped 1-dimmed arrays [a2ede36][4f4737d] + Added Mu.emit [4e76827] + Added --with-nqp Configure option for having NQP in a different prefix [6f6e6db] + Added .gist, .perl, and .Str to BOOTSTRAPATTR [3dd2916] + Made .sum nodal [4fd6e94] + Implemented uniprops [f55ff82][0328422][05db996] + Added 5 new sets of matching brackets for available delimiters [8965145] + Removals: + Removed X::Syntax::Number::InvalidCharacter exception [a8ff3b9] + Efficiency: + Made indirect type lookup 3x as fast [939d273] + Made shaped(int|num|str)array.AT-POS at least 15% faster [bfe89a5] + Made shaped(int|num|str)array.ASSIGN-POS at least 10% faster [ecc202e] + Made shaped(int|num|str)array.EXISTS-POS at least 20% faster [bbbb2b6] + Made 1-dimmed native arrays at least 3x faster [4a711bc] + Made native shaped array creation about 1.5x faster [1b840f1] + Made native 1-dimmed array init at least 11x faster [b6de5e8] + Made native 1-dimmed array copying at least 25x faster [b6de5e8] + Made use of native 2-dimmed arrays 2.5x–4x faster [172898e] + Made use of native 3-dimmed arrays 2.5x–4x faster [64343d7] + Made copying 1+ dimmed native arrays up to 9x faster [e0c0ae5][331c2e2] + Made copying intX[2;2] to intY[2;2] native array just as fast as copying intX[2;2] to intX[2;2] [79090b2] + Made native shaped array initialization 4x–6x faster [d704820] + Made iteration of 1-dimmed native arrays 17x faster [947422b] + Made iteration of >1 dimmed native arrays 11x faster [3e93ddd] + Made .(anti)pairs for native shaped arrays 7x faster [39261e7][471cea2] + Made .kv for native shaped arrays 16x faster [965fa4d][c1a3a3c] + Made native array.reverse|rotate about 20x faster [0ee6bc0] + Made @a[2;2] about 40% faster [b9e2ffa] + Optimized Int->int coercion [b2ac4e4] + Made infix:<..> on Nums 13x faster [a8ba26b] + Made uniprop with the default lookup 5x faster and other lookups 15% faster. [474ea33] + Made print, say and note 25% faster to stderr and stdout [e9ce28a] New in 2016.11 + Fixes: + Various improvements to warning/error-reporting + Fixed assigning values to shaped arrays through iterators [839c762] + Fixed Str.Int not failing on numerics with combining characters [d540fc8] + [JVM] Fixed .antipairs breakage [dd7b055] + defined routine now correctly authothreads with Junctions [189cb23] + Fixed poor randomness when .pick()ing on ranges with >32-bit numbers [34e515d] + Fixed infix: silencing Failures [2dd0ddb] + Fixed edge case in is-approx that triggers DivByZero exception [f7770ed] + (Windows) Fixed returning of an error even when succeeding in mkdir [208a4c2] + (Windows) Fixed precomp unable to rename a newly compiled file [44a4c75] + (Test.pm) Fixed indent of multi-line diag() and test failure messages [43dbc96] + Fixed a callframe crash due to boxing of NULL filenames [200364a] + ∞ ≅ ∞ now gives True [4f3681b] + Fixed oversharing with grammars used by multiple threads [7a456ff] + Fixed incorrect calculations performed by acotan(num) [8e9fd0a] + Fixed incorrect calculations performed by asinh(num)/acosh(num) [a7e801f] + Fixed acosh return values for large negative numbers [5fe8cf7] + asinh(-∞) now returns -∞ instead of NaN [74d0e36] + atanh(1) now returns ∞ instead of throwing [906719c][66726e8] + Fixed missing close in IO::Path.slurp(:bin) [697a0ae] + :U QuantHashes now auto-vivify to their correct type and not Hash [79bb867] + Mix/MixHash.Bag/BagHash coersion now ignores negative weights [87bba04] + arity-0 infix: now returns a Seq instead of a List [3fdae43] + Fix augment of a nested package [87880ca] + Smartmatch with Regex variable now returns a Match instead of Bool [5ac593e] + Empty ()[0] now returns Nil instead of False [f50e39b] + Failed IO::Socket::Async connection no longer produces unexpected crash [f50e39b] + Quitting Supplies with no QUIT phasers no longer unexpectedly crash [f50e39b] + Fixed NativeCall issues on big endian machines [627a77e] + Fixed broken handling of $/ in some uses of `.match` [ba152bd] + Fixed Lock.protect not releasing the lock on control exceptions [48c2af6] + MoarVM now builds on any version of macOS [b4dfed2] + Fixed concurrency crashes due to garbage collection [6dc5074] + Fixed race condition in EmptyIterator [ed2631c] + Fixed hang with multi-threaded long-running NativeCall calls [f99d958] + Made my @a[10] = ^Inf work [aedb8e7] + Fixed [;]:delete [3b9c4c9] + Fixed incorrect handling of negative weights in ∪ operator [e10f767] + duckmap now preserves types of Iterables [43cb55f] + Fixed premature overflow to Inf with large Num literals [729d7e3] + Fixed race condition in NativeCall callsite used by multiple threads [49fd825] + Fixed instabilities in programs launching many threads at startup [0134132] + Fixed crash when reporting X::Composition::NotComposable or X::Inheritance::Unsupported exceptions [a822bcf] + Fixed clock_gettime issue on macOS [ee8ae92] + Fixed SEGV in multi-threaded programs with strings-as-strands [395f369] + `regex` TOP Grammar rule will now backtrack if needed [4ccb2f3] + Fixed .rotate/.reverse on 1-dimmed arrays assigning to self [2d56751] + Fixed exponentiation involving zeros for Complex numbers [7f32243] + Fixed Label.gist [29db214][53d7b72] + Fixed certain edge cases of incorrect stringification of Rationals with .Str, .perl, and .base [b5aa3c5] + Additions: + Added TWEAK submethod for object construction [fdc90a2][9409d68] + Added DateTime.hh-mm-ss [bf51eca] + Added parse-base routine [7e21a24] + is-approx with no explicit tolerances now uses more complex algorithm to choose a tolerance to use (same as old is_approx) [82432a4] + on failure, is-approx now displays actual values received [b4fe680] + Added Iterator.skip-one to skip a single value [71a01e9] + Added Iterator.skip-at-least to skip several values [8d357af] + Re-imagined Str.match [b7201a8]: + the family of :nth is now lazy will return whatever can find + non-monotonically increasing :nth iterator values will now die + Str.match/subst/subst-mutate now have :as adverb [1b95636][c9a24d9][aaec517] + &infix: now works with Setty objects [d92e1ad] + :ov and :ex adverbs are now illegal in Str.subst [b90c741] + Made nextwith/samewith/nextsame/callwith to be real subroutines [70a367d] + Added CX::Emit and CX::Done control exceptions [07eeea8] + Setty.Mix/.MixHash coercers now use Int weights instead of Bool [7ba7eb4] + Implemented :kv,:p,:k,:v on 1-element multidim [;] [764cfcd] + .chrs can now also accepts codepoint numbers as Str [4ae3f23] + Added support for compilation of Rakudo on Solaris [a43b0c1] + IterationEnd.perl/gist/Str now returns text "IterationEnd" [59bb1b1] + Added X::Syntax::Number::InvalidCharacter exception [2faa55b] + .reverse/rotate on 1-dimmed arrays are now nodal [cd765e6] + .line and .file on core Code now references original source files [b068e3a] + .rethrow now works on unthrown exceptions [58a4826] + All Reals now accept `Whatever` as the second argument to .base() [c1d2599] + sub MAIN usage message shows possible Enum values if param is named and is an Enum [a3be654] + Efficiency: + Made slip(@a) about 1.2x faster [37d0e46] + Made initialization of 2+dimmed array 10x to 16x faster [dfb58d4] + Str.match is now about 5% faster [4fc17df] + Str.match with :nth feature is now about 2x faster [41e2572] + my @a = Str.match(...) is now about 5% faster [e472420] + Str.comb(Regex) is now about 7x faster [1794328] + Simple Str.subst/subst-mutate is now about 30% faster [364e67b] + Match.Str|prematch|postmatch is now about 2x faster [e65d931] + Match.Bool is now about 1% faster (not much, but used a lot) [1fce095] + Made ~~ /foo/ faster: 2% for successful/6% for failed matches [05b65d0] + Made ~~ /foo/ about 2x faster [e4dc8b6] + Made %h ~~ /foo/ about 2x faster [33eeb32] + Frequent accesses of multiple adverbs (e.g. %h :p:exists) is now 2x faster [f22f894] + Made infix: faster: Str: 14x, type: 10x, Range: 3.5x, Int|Seq|Hash: 1.5x, Array: 1.2x [bc7fcc6] + IO::Spec::Unix.canonpath is now 7x to 50x faster [f3f00fb] + Baggy.roll/pick is now about 10% faster [fc47bbf] + Made copying shaped arrays 10x to 20x faster [a1d8e93][0cf7b36][d27ecfa] + Made setting up a shaped array 2x as fast [f06e4c3] + Made creation of typed shaped arrays 15% faster [f5bf6c1] + Made 2d/3d array accesses about 7x as fast [d3a0907] + Made AT-POS on 1,2,3dim arrays about 20x faster [feb7bcb] + Made creating a shaped array about 50% faster [1293188][576f3a1] + Made .AT-POS on 3+ dimmed arrays 20% faster [1bb5aad] + Made over-indexed .AT-POS on 1,2,3 dimmed arrays about 10% faster [1bb5aad] + Made multi-dimmed ASSIGN-POS about 30% faster [5b2bdeb] + Made .ASSIGN-POS for 1,2,3dimmed arrays about 40x faster [050cf72] + Made n-dimmed .EXISTS-POS about 1.5x faster [006f008] + Made .EXISTS-POS for 1,2,3dimmed arrays about 10x faster [b1c41b7] + Made n-dimmed DELETE-POS about 1.3x faster [6ccecb1] + Made .DELETE-POS for 1,2,3dimmed arrays about 20x faster [55b9e90] + Made n-dimmed BIND-POS about 1.3x faster [2827edb] + Made .BIND-POS for 1,2,3dimmed arrays about 20x faster [9f94525] + Made @a[10].STORE at least as fast as @a.STORE [8064ff1] + Made .kv on shaped Arrays about 4x faster [e42b68e] + Made .pairs/.antipairs on shaped Arrays about 2.8x faster [0f2566a][f608a33] + Made List.kv about 30% faster [7a2baf4] + for loops on 1-dimmed arrays are now 3x faster [ed36e60] + .kv on 1-dimmed arrays is now 7x faster [608de26] + .pairs/.antipairs on 1-dimmed arrays is now 3x faster [b7d9537][1c425f9] + postcircumfix[;] on 2/3 dimmed arrays is now 9x faster [0b97362] + Assignment to [;] for 2/3 dimmed arrays is now 10x faster [ce85ba3] + [;]:exists for 2/3 dimmed arrays is now 7x faster [e3e3fef] + [;]:delete for 2/3 dimmed arrays is now 10x faster [3b9c4c9] + [;] := foo for 2/3 dimmed arrays is now 10x faster [eaf4132] + .iterator and .values on shaped arrays are now about 4x faster [736ab11] + Fixed optimization of shaped arrays that gives 10% gain on simple `for` loops and likely will give larger gains on bigger programs [b7e632e] + Made starting MappyIterator faster, affecting all Hash/Map/Baggy iterator methods. 2-elem Hash iteration is 1.6x faster [97fb6c2] + Made starting a grepper faster: .grep on with no adverbs on 2-element list is now 20% faster [077c8f0] + Made Date/DateTime creation 20% faster [0e7f480] + Hashes now use 4 (32-bit) or 8 (64-bit) bytes less memory per stored item [395f369] + Rational.Str is now about 40% faster [b5aa3c5] + Rational.base is now about 30% faster [b5aa3c5] + Various streamlining of code that's hard to measure the final impact of New in 2016.10 + Fixes: + Many fixes and additions improving JVM backend support + Several improvements to error messages + Fixed .tree([&first]) incorrectly calling .tree($count) candidate + Fixed unwanted errors when smartmatching objects against IO::Path + Fixed is-deeply with Seqs showing Seq.new-consumed() in failure text + Fixed concurrency race when setting up NativeCall routines + Fixed Match.list treating inner unmatched captures as end of list + .first now correctly handles Junction matchers + Fixed GLOBAL symbol clash re-compiling due to a repo change + Fixed Backtrace.map candidate being uncallable + Fixed multiple bugs in Hash/Baggy.classify-list/categorize-list + Fixed PERL6_TEST_DIE_ON_FAIL not exiting on failed subtests + Fixed autovification using Junctions as keys + Fixed infix:<^^>(Mu, Callable) candidate being uncallable + Fixed IO.l for dangling symlinks + Fixed infinite recursion in duckmap when mapper returned Any + Fixed .subst/.subst-mutate treating incorrect arguments as failed matches + Fixed .subst-mutate not returning all matches with :x + Fixed hang on smartmatching Promises against numerics + Fixed failure to smartmatch Numeric:U against Numeric:D + Fixed hang on incorrect .splice arguments + Fixed hang on incorrect .split offset + Fixed multi-argument WhateverCode not detected in double closures + Fixed Baggy:U ~~ Baggy:D emitting gut-referencing warnings + Fixed uncallable Dateish.IO + Fixed Exceptions::JSON for exceptions with no `message` method + Fixed Exceptions::JSON for exceptions with non-JSON-friendly attributes + Proc::Async decoding exceptions are now catchable + Prevented return handler being optimized out in `sub { 42.return }()` + Fixed error reporting when trying to invoke a native parameter + Fixed uncallable 0- and 1-arg candidates of infix: + Fixed Cool.match not setting $/ + Fixed Cool:U.IO coercion emitting internal warnings + Fixed Nil.chrs failing when called + Num:U++ now returns a Num zero instead of an Int one + Removals: + Removed argument-taking Dateish candidates for is-leap-year, days-in-month, and day-of-week [were never part of the spec] + Cool.IO no longer accepts any arguments + Overflow check has been removed from infix:<**>(int, int) + Additions: + Added basic Unicode 9 support (NFG changes for latest TR#29 still to do)) + X::Proc::Unsuccessful now includes command that was run + IO::Handle.new now uses 'utf8' encoding by default + Bare `put` now requires parentheses to call as sub + .head/.tail with no arguments now return the item and not a 1-item List + Added basic native attribute parameter binding + Made nativecast and spurt multies + Added .^elems metamodel method to enums + Enums can now be used to declare array shapes + Added X::Invalid::ComputedValue exception + Throw when dereferencing a null pointer in NativeCall + It's now possible to refer to sigiless parameters inside `where` clauses + Added extra candidates to .splice to allow for all combinations of Int|Whatever|Callable for both $start and $elems arguments + Made enums able to typecheck against the roles they do + Made Complex.new() return 0+0i + Int.new can now handle any value that can .Int + Added shortname() method to CurriedRoleHOW + Proc::Async new, stdout, and stderr methods now take :enc + IO::Socket::Async listen, connect, and Supply methods now take :enc + .Date and .DateTime are now supported on :U/:D Date/DateTime + Trailing empty cells can now be omitted in Pod tables + Mix/MixHash with non-Int weights can now be coerced to .Bag/.BagHash + Efficiency: + Made List.reverse about 5% faster + Made auto-threading about 10% faster + Made huge improvement to CUR::Filesystem.id performance + Made dir() about 20% faster + Made Regex.Bool about 2x as fast + Made Str.match about 3% faster New in 2016.09 + Fixes: + Various improvements to the content of error messages + Defaults on a slurpy params now throw instead of crashing at the VM level + Distribution::Path now handles native libraries correctly + Junctions now work in .classify + Control statements (e.g. `next`) in toplevel REPL now show useful error + IO::Handle.encoding now returns correct values + .comb/.split on binary handles now throws X::NYI + Fixed filehandle leak in precompilation + Regex in .grep and .first on Pairs now works correctly + Pod parser returns proper Bool instead of Int on passed config options + Fixed PERL6_TEST_DIE_ON_FAIL=1 exiting the test suite too soon or dieing on failing tests inside TODOed subtests + Fixed failure to accept enums as types for optional arguments + Fixed blocking bug when using socket accept and threads + Fixed fatal bug when using Non-ASCII tokens in regex/grammars + Fixed missing adverbs and candidates in Cool.split; made same as Str.split + Fixed missing adverbs in Cool.trans; made same as Str.trans + Fixed NativeCall CArray hanging when created from empty list + Fixed various issues with reading chars from an async socket (uncatchable exceptions on decode errors, and mis-handling of graphemes and multi-byte sequences over packet boundaries) + Fixed "%%foo @@bar" interpolation trying to find %foo and @bar variables + Fixed mis-compilation and possible compiler crash when using a construct like /$=@(1,2)/ + Fixed a memory leak involving EVAL + Fixed a multi-dispatch cache unbounded growth bug involving calls with many named arguments + Fixed warnings emitted when using hyper operators on two hashes + Channel.elems now returns a Failure rather than eating all values + Fixed type error ion IO::Path.rw + Fixed …, ???, and !!! yadas not working to stub classes + Fixed tab-completion issues with non-identifiers in REPL + Additions: + Coercions now work in return types + Added RAKUDO_EXCEPTIONS_HANDLER env var to control exceptions output + IO::Handle.slurp-rest now has :close flag + CompUnit::Repository::Installation now cleans up short-name folders when empty + Added support for very large numbers in :42foo colon pairs + Added a .Map coercer for object hashes + All Unicode quotes can now be used as quoters inside qqww/qww + LEFT/RIGHT DOUBLE PARENTHESIS characters can now be used with q and others + Unicode digits can now be used with Match variables ($١), quote pairs (:۳<12>), negative numbers (-١), and radix bases (:۳("22")) + Efficiency: + Numerous improvements in CUR, offering up to 10x faster module loading + Baggy.ACCEPTS(Baggy) is now about 25x faster + Baggy eqv Baggy is now at least 10x faster + Infix === now checks identicality, offering performance gains on large objects, such as a Bag with 1000 elements + Many metaops are now about 10% faster + Made Junction.Bool|ACCEPTS about 2x faster + Improvement in performance of IO::Path::child + Made permutations() about 5x faster + Made List.permutations about 40x faster + Made combinations() about 1.8x faster + Made List.combinations about 7x faster + Made Unix's canonpath several times faster for simple paths + Made Buf|Blob.reverse 1.5x faster + Made .IO.lines about 10% faster on large files + Changed APIs: + The operator precedence configuration rule `O()` has been changed to be more precompilation-friendly; rather than taking a string containing colonpairs, it now takes named arguments directly. This is not strictly a Perl 6 change, but rather a change in NQP, and thus only applies if you're doing fairly involved hacking on the grammar. If the sentences above made no sense to you, your code is not affected by this change. New in 2016.08.1 + Fixes: + Updated NQP version to avoid broken tag New in 2016.08 + Fixes: + Numerous improvements to content of error messages and addition of new previously-undetected warnings, such as on sinks and ... terms + Removed redeclaration error for anon subs + Concatenation/substr with strings constructed with repeat operator no longer results in incorrect strings + Fixed error for unknown symbol in parametric type + Things that produce a Seq no longer get constant-folded, avoiding bogus Seq exhaustion errors + where {} clause on unit sub MAIN no longer produces bogus errors + Fixed compilation and behaviour of :D on subsets + Assigning Nil to a :D variable now fails (unless its default is :D) + Fixed CURF's resolve generating the wrong repo-id + Fixed precomp file for Staging repo containing build path + Fixed merge global symbols failures when changing repositories + Fixed -Ilib and friends not overriding installed dependencies + Fixed <[a..z]> ranges breaking grapheme awareness + Fixed a race condition in Channel.Supply + Fixed an occasional deadlock when using the supply/react syntax + Fixed a race condition involving tearing down listening async sockets + start blocks now get their own fresh $! and $/ + .squish, .unique, .repeated, and .grep now correctly pass on .is-lazy + Fixed segfault on "multi cross{}" + .sort stored in a Callable no longer incorrectly returns BOOTArray + Smartmatch with two signatures, only one of which has slurpy hash, no longer produces spurious exception + @a.splice now returns array with correct descriptor + .rotor with negative gap that lands out of range now throws + Range.rotor with Rat arguments no longer crashes + .hash on Bag, Mix, BagHash, and MixHash types no longer stringifies keys + .abspath on filenames starting with '-' no longer results in empty string + generated setting file now has empty lines for those that were skipped in the past, allowing to directly map the line in a setting to the source code it was generated from + loop and repeat now properly self-sink + for { ... .map } now properly sinks + Backtrace::Frame.is-(hidden|routine) now returns Bool + Bool.Int now properly returns an Int + Starting the REPL with a module loading error, will now just exit + Names of phasers (such as BEGIN) will now be included in suggestions + Fixed loading of modules when a FileSystem repo doesn't actually exist + Fixed mis-scoping of blocks in s/// + Closure clones are no longer double code-generated + Caller $/ is now propagated through deferral + Fixed inconsistent coersions to Bool + Fixed over-assuming optimization of R meta operator + Fixed endless recursion in Any::BIND-POS under certain conditions + Additions: + Str.samemark('') now returns self instead of failing + Test.pm now provides bail-out() + Implemented $?MODULE and ::?MODULE + Implemented CompUnit::Repository::Installation::installed + InstalledDistribution now gets returned where appropriate + returns in signatures of many builtins now marked as --> Nil + .min/.max can now be called on Hashes + Invocant marker (:) can now be used in bare signatures + Added X::Syntax::NonListAssociative exception type + Hash[Any].new.perl now roundtrips + Buf.push|append|unshift|prepend also allow Blob:D + .succ now increments additional 29 digit ranges, such as Thai digits + List.sum is now marked as nodal + Can now return Nil as a result of a Promise + Implemented :exists on multi-dim assoc subscript literals + Added PERL6_TEST_DIE_ON_FAIL env var in Test.pm6 to bail out of the test suite on first failure + Efficiency: + Streamlined multiple internal code paths that may or may not result in performance improvements in user code + Improved dynamic variable lookup (2x as fast) + Hash.AT-KEY is about 35% faster + Hash.ASSIGN-KEY about 2x as fast + Hash.DELETE-KEY about 2x as fast + Hash[Any,Any].AT-KEY about 20% faster + Hash[Any,Any].ASSIGN-KEY about 15% faster + Hash[Any,Any].BIND-KEY about 15% faster + Hash[Any,Any].EXISTS-KEY about 10% faster + Hash[Any,Any].DELETE-KEY 10% faster + Repeated calls on Bag.WHICH now 5x as fast + Backtrace creation 25% faster + .first/.first(:end) iteration is now about 10% faster after testing 1000 elements + .minmax about 25% faster + .min/.max about 40% faster + min/max/minmax on native arrays is between 15x and 25x faster than non-native equivalent + Array.splice() almost infinitely faster and is much easier on memory (no longer copies anything but instead transplants internals) + Array.splice(offset,size) is now 20x to 40x faster for small offsets and sizes + Array.splice(offset,size,@) is about 10x faster + 10% improvement to .map/for in special cases of one-argument block that has a return signature that excludes Slips, such as -> Int $_ --> Str { .Str } + Many Set/SetHash methods are now at least 5% faster + Coercing a MixHash/BagHash to a Mix/Bag is now 300x faster + Coercing a Bag/BagHash to Mix coercion is now 1000x faster + Coercing a SetHash to a Set is now 80x faster New in 2016.07.1 + Fixes: + `make DESTDIR` now correctly finds CompUnit::Repository::Staging + .polymod with a lazy list no longer loses mods if the list runs out + Output from Test.pm6's diag() is no longer lost in non-verbose prove output when called at the start of the test file or during TODO tests + Bitwise operators that return int/Int no longer fail with candidate error when given a native int argument + Additions: + Improved error message when IO::Path.new is given incorrect arguments + Improved error message when .polymod is given a zero as divisor + Efficiency: + Str.samecase is now 5x faster + Str.indices is 10% faster + Str.rindex is 30% faster + Str.index is 30% faster New in 2016.07 + Fixes: + Mu can now be the result of a Promise + samewith() now also works on non-multi's + Many fixes in the area of pre-compilation and installing modules + Maps now correctly identify themselves as value objects + BagHashes and MixHashes no longer identify themselves as value objects + count-only and bool-only now are optional methods in Iterators (only to be implemented if they can work without generating anything) + Hash.Map now properly creates immutable Map + IO::ArgFiles.slurp / IO::ArgFiles.eof are fixed + Several wrapper file fixes + If a file is unknown in an error report, it is no longer shown (This typically happens in the REPL, or when doing an EVAL) + REPL whitespace and error handling + CompUnit::Repository::Installation no longer considers `bin/xxx` and `resources/bin/xxx` the same content address + Callable in a Signatures stringifies correctly + BEGIN time EVAL no longer negatively affects MAIN_CTX + Str.chop correctly works when given very large arguments + min/max on Failures throw instead of returning ±Inf + NativeCall's is mangled trait no longer ignored for CPPStruct + Additions: + The "is required" trait on Attributes can now take a Bool or a Str + Support for new leap-second at 31-12-2016 added + IO::[Path,Handle] gained a .mode method which returns the POSIX file permissions + Fixed LTA error message with Str.samemark when no pattern present + Distribution is now a role interface that enables encapsulating IO used for distribution installation + CompUnit::Repository::Installation now uses the new Distribution interface + The original distribution META `provides` data is now preserved + Custom repository implementations now supported, including precompilation + List.BIND-POS now fails instead of throwing + RAKUDO_JDB_PORT and RAKUDO_PRECOMP_NESTED_JDB debug environmental variables + Failures in Cool.Numeric and related coercers now get propagated + Improved warning message for literals with leading zeros + Improved error message for attempts to `use` core types + Efficiency: + The MMD cache accepts candidates with named parameters if it can. (This made adverbed slices about 18x as fast) + Str.samemark is 50x faster + Str.contains is 6x faster + Baggy.pick(N)/pick()/roll()/grab() are 6x faster + Array.List is 5x faster + List.elems is 4.5x faster + for/map with 2 arguments is 4x faster (e.g. for @a.kv -> $i, $v { }) + Str.substr-eq is 4x faster + List.Bool is 4x faster + Str.chop is about 3.5x faster, Str.chop(N) 20% faster + Map eqv Map is 3x faster + Make "for List.pairs {}" 2.5x faster + Array.pop is 2.5x faster + List.AT-POS/EXISTS-POS are 2.5x faster + Creating arrays with [] is 2.5x faster + Array.AT-POS/ASSIGN-POS/BIND-POS at least 2x faster for unreified elements + Array.DELETE-POS is 7x faster + Str.starts-with is 2x faster + Array.shift is 2x faster + Baggy.roll(*) is 2x faster + Blob/Buf.AT-POS is 2x faster (underlying method of e.g. "$buf[2]") + List.STORE is 2x faster (e.g. "my ($a,$b,$c) = (1,2,3)") + Make "for List.kv {}" 1.8x faster + Array.push/append is 40% faster + Str.comb 30% faster + Map/Hash initializations are now 30% faster + A slurpy taking a list is 30% faster ("sub a(*@a) { }; a(1,2,3,4)") + Str.ends-with is 25% faster. + Str.chomp is 20% faster + single element for/map in sink context without phasers, is 20% faster + Pair.new is 10% faster + val() is 5% faster + {}|[]:adverb is 2.5x faster + foo xx Int is 10% faster + Str.Int is 5% faster + Code.arity|count are 2x faster New in 2016.06 + Fixes: + Arrays with holes (e.g. from :delete) now correctly iterate/auto-vivify + Hash.keyof now correctly returns Str(Any) + Precompilation from a debug Perl 6 now uses "normal" Perl 6 executor + Inf,NaN,-Inf now can be coerced to Rat, and back to Num + Creating an Enum from a List/Range no longer warns + Precompilation on file systems with coarse timestamps no longer fails + An issue with reverse dependencies of installed modules was fixed + Fixed issue with comparing v6 and v6.c Version objects + Fixed ≅ ignoring the signs of compared numbers + Additions: + Add default for CompUnit::PrecompilationRepository.precompile(:source-name) + The "is-approx" sub from Test now allows for relative/absolute tolerance + The "cmp-ok" sub from Test now can take any infix as Str, even custom ones + A fail in a custom BUILD will now be returned, rather than thrown + use MONKEY-WRENCH and use MONKEY-BARS are now reserved names for future use + Efficiency: + .map between 10% and 30% faster + .unique, .repeated and .squish 10% to 20% faster + gather/take about 10% faster + Basic object creation (using either .new or .bless) now up to 3x faster + (+@a), (*@a) and (**@a) signature handling between 20% and 4x faster + Iterating List/Array now uses less memory and is faster + All routines now have less overhead, thanks to improved implementation of return handlers (including those that do not use return) + return, next, last, and redo are now all faster + infix:<,> about 40% faster + numerous other smaller or edge-case speed improvements + Deprecations: + The "is_approx" sub (note underscore) from Test New in 2016.05 + Fixes: + Fix EVAL during precompilation + .substr fixes + many precompilation fixes + clean up error messages + Streamline some core classes + Harden Mu.Str against moving GC + JVM fixes + Simplify $*USER/$*GROUP initialization + Additions: + Ability to use a customer debugger module + $*MAIN-ALLOW-NAMED-ANYWHERE allows MAIN to be friendlier about where it accepts flags + Add richer set of comparison operators for Versions + Many improvements to precompilation - building OS packages with precomp'd code should now be possible! + Introduce .Map coercer + Implement alternate ways to call subtest + Efficiency: + Version comparisons are now 2x faster + List.minmax is about 3.5x faster + Num.perl is about 2.4x faster + Int division/modulus is about 1.5x faster + LoL accesses are about 3x faster + autothreader is about 2-3x faster + Make Any junction methods 14x faster + Make Junctions faster + Map.kv is about 10% faster New in 2016.04 + Fixes: + .combinations cleanup + "magic" inc/dec cleanup + utf8-c8 encoding crashes that occurred on random data + fix missing pre-comp store unlock + missing module error mentions line number + some JVM fixes + Additions: + Improved REPL + Add :kv to .first + Add provisional $*DEFAULT-READ-ELEMS + Efficiency: + Removed leaks associated with EVAL + Speed up .minpairs/.maxpairs + Speed up Object:D cmp Object:D + Speed up sort 3-15% New in 2016.03 + Fixes: + Buf.push|append|unshift|prepend now can take int arrays + Better error messages when trying to put illegal values into Blob|Buf + The REPL now allows statements spread over multiple lines + No longer show compilation error twice when loading module with errors + Only Bufs can now be specified as parameter to subbuf-rw + Values in %*ENV now have allomorphic semantics + Supply.Channel / Channel.Supply no longer lose exceptions + Calling .prepend on a native array no longer infiniloops + Blob.WHICH now indicates a value (immutable) type + Better error reporting for problems with sprintf() + Some obscure unicode codepoints causing segfaults no longer segfault + Directory listings now handle wrongly encoded data using utf8-c8 + Additions: + Native str arrays (my str @a) + Buf.pop, Buf.shift and Buf.splice (similar to List.*) + Blob|Buf.allocate($elems, @init-pattern) + Buf.reallocate($elems) added + &*EXIT can be set to handle exit() statements (for embedding Perl 6) + Efficiency: + Auto-generated accessors/mutators use less memory and are faster + Most Blob|Buf related options use less memory and/or are (much) faster + Same for much of the native array support and IO reading operations + Many Parameter/Signature related options are much faster + Punning a role is much faster + Modules can now be shared between rakudo versions + Reordering "use lib" statements made NativeCall tests 3x as fast New in 2016.02 + Fixes: + Many memory leaks fixed in MoarVM + Fix several issues with "require" + .perl of an iterated Seq (RT #127492) + Set.hash now returns an object hash (RT #127402) + Use the order of arguments in usage display, rather than hash order + Exception.fail now dies reliably outside of a routine + fix problem with Str.split with multiple overlapping needles + Map.Hash now correctly separates from the Map + Fix roundtrip issues of Instants + Specifying ::a now gives proper compile time error (RT #127504) + Rakudo jars are now installed in the proper location + Enums with a type object now fail with an NYI error + .first(:end) on uncached iterators no longer fails + Additions: + Buf.unshift/Buf.prepend + DateTime.new(y,mo,d,h,mi,s) fully positional candidate + Can now uninstall distributions + Date/DateTime now fully subclassable + REPL now supports multi-line statements (experimental) + Efficiency: + Str.trans can now be up to 160x faster + @a.chrs noq 3x faster, chrs(@a) now 9x faster + Many Map/Hash related functions can be up to 2x as fast + Magic increment/decrement on strings 2x as fast + Some percentages improvement in object creation, phaser handling, summing, creating failures. + Object hashes re-implemented using 1 internal hash, instead of 2. This results in about 10% less memory usage, and a few % less in CPU New in 2016.01 + Fixes: + Chained .grep calls on Supply fixed (RT #127297) + Fixed interaction with perl6-debug and precompilation that resulted in an endless loop + re-enabled warning when smart-matching against a True or False literal + Fixed internal error when reporting certain type errors (RT #127207) + Fixed rare "duplicate definition of symbol" errors (RT #127107) + Fixed interpolating of pairs with non-key strings into signatures + Fixed error when smart-matching Seq against a Set (RT #127166) + Improved error message when smart-matching against an S///-expression + Fixed bad interaction between EXPORTHOW and multiple declarations (RT #126566) + Fixed various issues regarding precompilation + Improved accuracy of Complex.sqrt + hyper now preserves order of results, as designed + Range.sum on an empty, numeric Range is now 0 + Fixed Promise.allof() with an empty list of promises (RT #127101) + Improved message on premature virtual method call (RT #127097) + Better error message for module load failures of types that are part of the setting + Support for Readline in addition to Linenoise New in 2015.12: + Features + Fixed size and multi-dimensional typed and native arrays + Greatly overhauled module loading and installation, including handling precompilation at module installation time in Rakudo + Automatic precompilation of modules + 'no precompilation' pragma to opt out of precompilation + Can now specify the backlog for listening sockets + NativeCall now knows the size_t and bool types + Give IO::Socket::INET connect/listen methods + while/until loops can now return lists of values + We now catch many more kinds of "Useless use of X in sink context" + On the flip side, the optimizer now has a much better idea of what is sunk + A number of convenient Unicode equivalents were introduced + Superscripts can now be used for integer powers + Non-digit unicode characters with a numeric value (½ and such) can now be used for that numeric value + There is a new "approximately equal" operator + The .narrow method can narrow things that are approximate integer + Allow quoted words as input for Buf.unpack + Can now mix in to enums + Implement List.first() + Added Supply.head and Supply.share + Implement Range.rand + Add support for USAGE argument help + Provide tau constant (also: τ) + Can now use channels with supply/react/whenever + Implement %?RESOURCES + Allow for :every *and* :times in SCHEDULER.cue + Implement Promise.at + Add .Date/.DateTime coercers to Instant + Implement native-descriptor on handles/sockets + Add UDP support to IO::Socket::Async + Switch to doing newline translation at I/O boundaries + Add support for specifing the api/abi version to native (NC) routine + Greatly improved support for sized and unsigned native lexicals + Implement CLOSE phaser for supply blocks + Respect multi's sigs in role composition + Treat multis with equivalent sigs as collisions + New method $*VM.platform-library-name + Incompatible changes + Bool is now a proper enum + Supply.new replaced by Supplier.new + An exact arity match in multiple dispatch beats slurpy/optional + Supplies consistently treat list values as single arguments + Remove grep-index/first-index/last-index for attributes in grep/first + Remove support for Str.split(:all) (use :v instead) + Changed IO::Socket::Async reading API to .Supply method + Order Complex first on .re, then .im + Order ranges first on min, then on max + Use of EVAL now requires a declaration of 'use MONKEY-SEE-NO-EVAL' + Likewise regex interpolation is limited in the absence of the declaration + Empty loop modifiers must now use Nil to avoid "useless use" warning + Thunky operators now thunkify arguments even when used in metaoperators + SEQ() is renamed to STATEMENT_LIST() to avoid extra overloading of 'sequence' + Tweak attribute initializer semantics match assignment semantics + Make @a[^2] consistent with @a[0,1] + Make ::= a NYI, in light of 6.c + Promise.Supply is an on-demand Supply + Remove earliest syntax + Forbid argument-less Date.new + Forbid Instant.new + Remove IO::ArgFiles.nl + Move sub-byte native int types to experimental + Enforce return types in pointy block sigs + Kill off has-accessor; use has_accessor instead, consistent with MOP + Make X, Z, and roundrobin respect items + Fix loss of structure in xx + Enforce SSA on sigilless in `my (\x, \y) = 1, 2;` + Remove IO::Socket::Inet.input-line-separator + Remove IO::Socket::Async.(bytes|chars)-supply + Remove IO::Handle.(ins|nl) + Remove IO::Handle.seek(pos,Int:D whence) + Promise.[anyof|allof] no longer break + Make pack and unpack experimental + Fixes + Dynamic variables are now visible inside start { ... } blocks + Sparse array no longer acts empty on shift + Disallow positions < 0 on index/rindex + Make "require PACKAGE/STRING" return said PACKAGE/STRING + Fix BEGIN/CHECK block scoping precompilation bug + Fix bug in the scheduler that could swallow exceptions + Supply.from-list should follow 1-arg rule + Prevent data loss in various cases with async sockets and processes + Autoincrements on native ints are now faster than on Int + The ~~ operator can now chain with other comparisons in many circumstances + Imported operators no longer lose their precedence info + Various numeric operations now return overflow/underflow failures instead of wrong value + The :ss, :ii, and :mm options to s/// now all work together + Ranges and complex are now ordered more consistently + Mixin Callable[$type] for all ways of declaring return type + Don't ignore return types when calling ACCEPTS with Signatures + Make MMD setup of sub print same as say/note/put + Fixed circular module loading detection + Cool.substr-eq should return a Bool + Fix some failures to catch return outside routine + Stop phaser loop swallowing loop exceptions + Fix FIRST in loop/while/until + Consistently return Nil for no value, not a typeobject + Import should reuse precedence of exported ops + Fix slurpy hashes in Signature ACCEPTS + Fix SomeRole.^roles + Make :transitive the default for .^roles. + fail should reliably die if outside of a routine + Make slicing with adverbs respect itemization + Fix return type of qqw{...} + Make (1,2,3)[2] = 4 and (1,2,3)[3] give same error + Show non-printables in IO::Path.perl New in 2015.11: + Features + Initial shaped array support + \r\n (Carriage Return/LineFeed) is now a single (synthetic) grapheme + Unicode support adheres to Unicode Annex #29 + New IO::Handle.nl-in now allows multiple line-endings to be set + New IO::Handle.nl-out allows you to set line-ending used in IO::Handle.say + New IO::Handle.split/comb, same feature set as Str.split/comb, but lazy + IO::Handle.seek now accepts new SeekType enum values as 2nd parameter + New $?NL contains the output new-line character(s) for the current system + New 'use newline' pragma allows setting of $?NL + New List.head/tail methods for easier getting first/last N elements + New List.repeated for only getting repeated values in a list + Str.encode now allows :replacement parameter for unencodable sequences + Str.split now accepts multiple strings to split on + Str.split now accepts :v, :k, :kv, :p, :skip-empty named params + Str.comb(Int:D $n) candidate allows for combing string per $n characters + New Range.int-bounds returns first/last value for integer ranges + EVAL now passes on named params, to allow for customised EVAL subs + Auto-generated meta-ops vivified by referring to them, instead of executing + Unicode quotes are now also allowed in regular expressions + Can now coerce to generic types in parameters + Can attach adverbs to variables + Illegal assignment of different Numeric values now caught at compile time + &nextcallee implemented, which returns the routine that nextsame would invoke + Deprecated + IO::Handle.nl should either be IO::Handle.nl-in or .nl-out + IO::Handle.seek with a numerical value for 2nd parameter + Str.split( ... :all) should be written as :v + Fixes + RT #74414: the multi dispatcher now treats "is rw" parameters as tighter matches + RT #125123: improved error message for type check failures in int-typed arrays + RT #126436: improved error message for missing required attributes + multi submethods aren't inherited to subclasses + leading escape sequences representing whitespaces aren't stripped anymore from heredocs + Speedups: + [+] and sum + Blob.subbuf + List.sort + List.roll + List.rotate + List.reverse + IO::Handle.getc + Build system + New options --sdkroot and --sysroot to Configure.pl to support cross builds New in 2015.10: + Features + We are now officially in beta! + There is now an infix:<.> operator that does method calls with slightly looser precedence than the postfix unary method call. + Definite return values are now allowed, and force final statement to sink + Types with type smilies (like 'Int:D' and 'Int:U') are now first class, and supported in constraints for variables, for example + New pragmata 'use variables :D', 'use attributes :D' for defaulting type constraints to ':D' + The 'constant' declarator now supports syntactic constructs, so you can alias with 'my constant &infix: := &infix:<+>;' + New operator 'infix o' for function composition + New method 'produce' for triangle reduce + 'fc' for Unicode-correct case folding implemented + '' assertion in regexes implemented + Methods 'file' and 'line' in 'Code' point to the location of the declaration + grep now accepts :k, :v, :kv, :p attributes + first now accepts :k, :v, :p attributes + first also accepts :end attribute to indicate searching from end of list + 'is equiv<+>' as shortcut for 'is equiv(&infix:<+>)'. Same for 'tighter' and 'looser'. + 'Supply.throttle' for rate-limiting + 'Hash.append' added, now that Hash.push doesn't flatten + Internal methods ZEN-POS/ZEN-KEY added, for handling zen-slices + Promise.start now passes on any extra parameters to async block + Use of comma in sink context now distributes sink to its parts + Attribute containers may now have defaults + The new .self method is the identity method on anything + Negative integers are now allowed in the parameter slot + List associative operators can now be autoprimed, including Xop and Zop + Incompatible Changes + Array.push is now used for pushing one element (mostly); Array.append exists for pushing multiple values. Same for 'unshift'/'prepend' + Basic arithmetic operations ('+', '*', '-', '/') on Range objects that shift or scale the end points while maintaining exclusions + 'is rw' now only works on scalars (was a noop), and actually requires a writable container. Parameters of the form '\x' enable the old behavior + The v notation now allows alphabetic components: v1.2.beta. (Incompatible because method calls on a version must be protected by \ or () now.) + 'use v6b+;' notation is now recognized and enforced + Many list functions no longer flatten, or use one-arg flattening only + The sequence operator no longer flattens sublists, so you must use slip to get that effect + The precedence of infix:<.=> is now tighter to match new infix:<.> + Smartmatch with List now recursively uses smartmatch + Smartmatch with list now globs using '**' rather than '*' + callwith/nextwith no longer flatten + Speedups: + Many built-in methods that return iterables are now much faster + 'Bag' and 'Mix' are now faster + Rat addition/subtraction is now faster due to lazy reduction when consistent denominators are used ("cents stay cents") + Fixes: + Better error messages when comparing version strings with numbers + Several error messages that were lacking line numbers now include them + Anonymous types now compare correctly under 'infix:<===>' + Fixed 'once' block semantics (RT #126293) + A dying 'LEAVE' block doesn't prevent other 'LEAVE' blocks from running anymore + 'Str.tc' now does an actual Unicode title case operation + polymod had not been GLRified yet + List/Supply.squish did not properly handle single element lists/supplies + Several fixes to the REPL, e.g. with regards to completions + with/without now topicalize properly + Fix usage of match variable in replacement part of substitution + ».[1;1] (hyper on multidim subscript) now works + Methods map, push, pop, shift, unshift, append, prepend now properly marked as nodal + Attempt to smartmatch with S/// now warns + grep { /foo/ } now dwims again + Operator names now canonicalize internally to legal Perl names + Reduction ops now generalize to N-ary functions + Extra list comma is now allowed before any statement modifier + Various multisubs now report .arity more accurately + Exceptions can now correctly report the Nil type + Deprecations: + grep-index() deprecated in favour of grep(:k) + first-index() deprecated in favour of first(:k) + last-index() deprecated in fevour of first(:end,:k) New in 2015.09 + Features + Great List Refactor + New slurpy parameter, +args or +@args, to allow for one-argument style binding + New with/orwith/without conditionals allow you to check for .defined but topicalize to the actual value returned + New 'supply', 'whenever' and 'react' blocks for easy reactive programming + Mu.return implemented: allows for ".return with $foo" + Cool.indices/indices() expands on Cool.index/index() functionality + Callframes now allow easy introspection of associated Code object + Test.pm now has a 'does-ok' function for testing role conformance + '$¢' in grammars now refers to the current cursor + All Unicode digits can now be part of literal numbers + 'val()' and allomorphic types implemented + Most European quoting styles are now supported + The parser now detects and reports possible runaway quotes + New $[...] and ${...} constructs allow prefix itemization + 'dd' now displays variable type + Fixes: + Using a Range with an infinite .max now works on substr()/.substr + Parameter aliases are now handled in MAIN subroutines + Fixed typo about environment access in IO::Spec::Cygwin.tmpdir + Blocks like { .foo } are no longer considered to be a Hash constructor + Propagate ignorecase into subrules of regular expressions + eqv no longer defaults to === semantics, but snapshot (via .perl) + A constant declaration now pays more attention to its sigil + The .gist and .perl methods can now deal with self-referential structures + andthen and orelse are now topicalizers as specced + Fixed CompUnit.load, which is what use/require uses under the hood + Incompatible changes: + Creating constants with a ? twigil has become a NYI for now + No longer allowed to create dynamic constants with "my constant $*FOO" + Forbid to use the very same variable to init itself directly in declaration + Parcel is no longer a type, use List instead + 'is parcel' trait is now 'is raw' + .gist now puts brackets around lists and arrays + IO::Handle::lines no longer returns an empty last line + The 'Enum' type is gone; use 'Pair' instead. + Deprecations: + All Deprecations removed in preparation for Christmas release + NativeCall: + Added support for calling into C++ libraries and calling methods on C++ classes New in 2015.07 + Features: + Cool.substr(-rw) and &substr(-rw) now also accept a Range + Added trait "is required" on class attributes + Parameters like :n($n) are presented as :$n in .gist + &?ROUTINE and &?BLOCK + Conversion forms now understand :16(':8<377>') and such + &words implemented (to completement .words) + Numeric comparison ops (== > etc) for DateTimes + Fixes: + ENTER phaser now can be used as an r-value + Allow %{Type} as a way to say Hash[Any,Type].new + Several issues with the use of ';;' in signatures + Issues with regexen throwing an exception (RT #62086 & #72440) + samewith() now also works in subs + Calling the .clone method with alternate values no longer changes original + Various fixes and optimizations on List.splice + .grep and &grep now consume multiple elements for many-param blocks + Issues with precedence limit checking in EXPR fixed + EVAL now pays attention to languages in the compiler registry + Incompatible changes: + my Type $a is default($value) is now compile-time checked + my $a is default(Nil) only works on untyped (Mu) variables + Can no longer (roulette) assign to Whatever slice of a hash + Emit warning when \$ \@ \% \& are used to create a Capture + Now illegal to use a contextual ($*c) before declaring it in a block + EVAL :lang instead of for consistency with use :from + Deprecations: + $*PROGRAM_NAME in favor of $PROGRAM-NAME + $*EXECUTABLE_NAME in favor of $EXECUTABLE-NAME + pipe() in favor of shell() or run() with :in, :out or :err New in 2015.06 + Features: + Lexical pragma 'use trace' now outputs statements on STDERR + $=finish now contains text after first =finish/=for finish/=begin finish + __END__/__DATA__ now marked as obsolete Perl 5 features + Added :as named param to .classify / .categorize + EVALFILE added, for evalling source in a file + Implemented 'quietly' statement prefix to prevent warnings being issued + MinGW (Windows with gcc/gmake) is now also supported besides MSVC + Implemented 'has Type method' + Implemented Buf.push + Implemented S/// (returns the new string rather than in-place substitution) + Implemented X::StubCode for .../!!! code + Add :createonly to rename() + Fixes: + (10e6).pick/roll no longer build the whole list to pick a value + Regex.gist/perl return source of regex + start now takes a statement also, or a block (as before) + .push/.unshift on typed arrays now create the right type of container + Throwing a Failure counts as handling it + Incompatible changes: + DateTime default timezone format is now +HH:MM (used to be +HHMM) + "".IO / IO::Path.new("") no longer legal, use "." for current dir + next/last/redo don't allow expressions to be evaluated anymore + sign(NaN)/NaN.sign is now NaN + Stubbed-out code (via .../!!!) no longer results in X::AdHoc + Deprecations: + Using start as a sub with parentheses, e.g. start( { ... } ) + open(:p) New in 2015.05 + Features: + NFG, NFC, NFD, Uni + Implemented unicode property pairs with explicit arguments, e.g. <:NumericValue(0 .. 1)>, <:Name(/LATIN/)> etc (MoarVM only) + :m/:ignoremark implemented (now that we have NFG) + Implement <&foo: $arg>, <&foo($arg)> and my $a = "alpha"; /<::($a)>/ + List/Supply.rotor expects a list of Pairs (elems|elems => gap) + Added much faster List.pick(*,:eager) variant + Implemented CLIENT:: (nearest CALLER:: from different package) + Normal stacktraces no longer include references to code in settings + RAKUDO_BACKTRACE_SETTING to *do* include code in settings + RAKUDO_VERBOSE_STACKFRAME environment variable shows source lines + Warnings now show file/line unless the end with a newline + Implemented "is nodal" for signalling behaviour under hypers + Rudimentary tab completion available via the Linenoise module + Incompatible changes: + The readline integration that existed on the VM level has been removed; it now exists as a module. To restore readline operations in the REPL (ex. history, line control), install the Linenoise module via Panda + "unit" declaration needed for blockless packages + Various API changes for the Great List Refactor, such as... + 'for' loops not longer flatten; use 'for flat' for that + .map no longer flattens, map as a listop does. Use .flatmap to get the old behavior + Likewise other methods that used to flatten their invocant no longer do: all, any, one, none, unique, squish, min, max, minmax, classify, and categorize + Nil no longer iterates like the empty List. Use () or Empty instead. + Hashes no longer maintain insert order on Moar (on JVM they never did) + @*INC now contains strings (again), rather than CUR objects + Item seperator in INC spec is now "," + Type / info seperator in INC spec is now "#" + .pick($n)/roll($n) now always return lists, even when $n == 1 + $?FILE is now always an absolute path + Variable will init/post/compose throw NYI instead of silently doing nothing + The "is cached" trait no longer works on methods, throws a NYI instead + Deprecations: + Method .map should be used instead of .for + List/Supply.rotor now *must* have elems and gap specified + Test.pm functions are now kebab-cased (e.g. throws_like -> throws-like) + in regexes, avoid non-significant whitespace between alphanumerics + Unhandled Failure leaks are now warned about if detected by DESTROY + Fixes: + Many race conditions, specifically wrt to role specializations + Hashes use much less memory on Moar + my $a will begin/enter/leave/keep/undo/first/pre now set $_ properly + List.roll(Inf) now knows it's infinite, so is lazy + The REPL is strict by default now, that leaves only '-e' lines to be lax + Undeclared variable compile time error made clearer + IO::Handle.lines(:eager)/.words(:eager) now properly eager again + 'earliest' now handles remaining channels without specific handlers + Int/Rat ** -Int now generates a Rat if possible, else a Num + IO::Path.resolve now returns IO::Path as specced + CALLER now produces consistent results in the dynamic scope of implicit protos + A regex may now be used as the smartmatch of a sequence operator + Fix /a ~ (c) (b)/ capture order bug. + map <:alpha> in regexes etc to proper lookup on JVM + site/lib is now in the C library (.dll/.so/.dylib etc) search path + Fix scoping bugs with statement modifier for and given. + Make { 1 R=> 'a' } and { %*h } construct hashes. + Fix lexical context of regex interpolations + Various list ops now report .is-lazy correctly + Speedups: + generating backtraces is now lazy, improving the speed of e.g. warnings + Make List.pick about 3% faster, List.pick(*) about 7% faster + Implement new @*INC handling (about 30% faster startup time) (bare startup time is now below 100 ms on some machines) + NativeCall: + Implemented CUnions which map to the union C type definition + Implemented HAS declarator for attributes to mark it embedded into the CStruct or CUnion New in 2015.04 + Incompatible changes: + Installation directory layout changed: it now uses $PREFIX/share instead of $PREFIX/languages + "0" (0 as a string) is now True, no special-casing anymore + an Int() coercion type in a multi now creates two candidates: Any and Int + Fixes: + try now implies "use fatal", so failures are not leaked + "use fatal" now only works in its scope, and not in deeper ones + don't constant-fold Failures + throws_like will EVAL code in context of caller + pragma's like "strict" can now also be called with -M on the CLI + once a List is infinite, it will stay infinite (fixes several hangs) + can now slice an Infinite list into a finite slice + can now slice a finite list into an infinite slice + adverbs are now allowed inside a ternary + auto-generated accessors will not show up in backtraces anymore + $_ now defaults to Any, rather than Nil + intuited iterators no longer bypass endpoint if no exact match + intuited iterators may also skip literal values if endpoint is lower + intuited iterators beginning/ending with same length now according to spec + say now observes the .nl setting + exceptions in BEGIN blocks and constant are now handled better + binding now works again in the REPL + various other REPL fixes + \foo variables work properly in EVAL + declarations like my (Str $ing, Int $eger) correctly enforce types + detect and complain about placeholders in attribute initializers + use of | prefix in the wrong place now complains at compile time + \(...) capture constuct handles nameds and | correctly + regex interpolation now uses cursors instead of scanning + correct line numbers are reported for faling tests + Deprecations: + the RC release in September will remove *all* deprecations + "use nqp" now required for silent use of nqp::ops + Features: + native arrays + 'bit' and 'byte' native types + starts-with/substr-eq/ends-with for comparing strings inside other strings + first steps towards generic lexical pragma's (e.g. soft, strict, nqp) + basic implementation of Uni, NFC, NFD, NFKC, and NFKD on Moar backend + Uni.Str coercion produces an NFG string + chop now takes optional number of characters argument + where constraints on variable and attribute declarations + dists are installed into a database-like way by default (via panda) + 'is rw' parameters implemented for native subs (they get passed as a pointer) + complex and rat literals now work inside of a <> quote + attempting to bind a Failure now tells you what was in the Failure + reduce() now pays attention to associativity (which is now part of the op) + can now reduce ([Z]) with list infixes over an arbitrary number of lists + use Foo:from supported when Inline::Perl5 is installed + EVAL $code, :lang supported when Inline::Perl5 is installed + Speedups: + Str.codes/chars/uc/lc/tc/tclc/ord/flip about 25% faster + List.pick about 10% faster + Mu.clone about 8% faster + make xx about 1.8 times faster + several speedups in matching + numerous Num.Rat optimizations: 6.5x faster New in 2015.03 + Incompatible changes and deprecations: Any code *calling* the old method names, will be given a deprecation warning, and will continue to work. Any module that *implements* MMD candidates for any of these methods with their old name, will probably break. Please start using the new names as described below. + renamed internal hash/array/code/* methods: - OLD NEW - at_pos AT-POS - exists_pos EXISTS-POS - delete_pos DELETE-POS - assign_pos ASSIGN-POS - bind_pos BIND-POS - at_key AT-KEY - exists_key EXISTS-KEY - delete_key DELETE-KEY - assign_key ASSIGN-KEY - bind_key BIND-KEY - invoke CALL-ME - Supply.on_demand Supply.on-demand - Supply.schedule_on Supply.schedule-on + renamed traits - hidden_from_backtrace hidden-from-backtrace - hidden_from_USAGE hidden-from-USAGE + Deprecated use MONKEY_TYPING for use MONKEY-TYPING. + Incompatibility change: spaces are no longer allowed in operators. + Disallow redeclaring constants in the same scope + Throw redeclaration error for duplicate type capture + Deprecate IO::Handle.input-line-separator for .nl + Remove parrot support from Rakudo. + Don't print deprecation messages if RAKUDO_NO_DEPRECATIONS env var is set + Features + Allow Buf.AT-POS to return an l-value. + Implement method ^foo($) { ... } syntax. + Implemented PairMap (the simple case only, for now). + Implemented .antipairs (pairs with value => key). + Implemented .pairup for creating pairs from lists. + Implemented LEXICAL, OUTERS and CALLERS pseudo-packages + Implemented UInt (sub)type and coercer. + Add a array[T], usable for native int/num (MoarVM only for now) + Other native improvements, e.g. my int $a; $a++ + Smart quotes (as in “foo”, ‘bar’, ‚baz’ and „zap”) now also supported. + Improve and test support for Listy types in JVM Interop. + Hyper-infixes (like »~») are faster and have more features. + Make token prefix properly compete with term in LTM + not() and so() are functions as well as prefixes. + substr-rw() now accepts the same range of parameters as substr() + keywords now require whitespace (unless shadowed), which allows: my \if = 42; say (if) if if; # now says 42 + Implement IO::Path.resolve on r-m/POSIX + Catch P5ish use of $/ + Fixes + Catch wrong attribute usage in a regexes. + Fix compiler warnings on OS X / JVM backend + bare say now complains about no valid arg + Make .invert no longer infiniloop + Make List.kv completely flatten its values + Update error message for $] to use $*PERL.version + Fix JVM runner generation on Windows. + fix $*KERNEL.arch for raspbian, ugexe++ + Make $?TABSTOP immutable + Make CALLER::<&?ROUTINE> work + Errors like "expected Array[Str] but got Array[Str]" have been fixed. + Optimizations + Make my int/num @a = Range about 1000x faster + Make generic Str.subst between 5 - 10% faster + Make s/// up to 25% faster (for many changes) + Make Bool.pick and Bool.roll up to 2x faster + Make Bool.pick()/roll() another 10% faster + Make substr(-rw) about 10% faster + substr("foo",1) 2.5x faster + substr("foo",1,2) 6x faster + substr("foo",*-2) 1.5x faster + substr("foo",0,*-2) 1.5x faster + Make %h = 42 about 10% faster + Test.pm changes + Several improvements in Test.is() wrt to handling type objects and whitespace. + Add simple use-ok implementation + NativeCall.pm changes + 'is native' will also accept Callables to allow runtime library detection + Implemented nativesizeof(T) + Add typed Pointer type as replacement for OpaquePointer + Throw exception for wrong arity in native subs New in 2015.02 + Overriding invoke/postcircumfix:<( )> for type coercions (ex. MyType(...)) now passes the function arguments as-is, rather than just passing a Capture containing them + optimizations to slices with adverbs + improved error messages from sprintf and fmt + improved error message when trying to inherit from a class that isn't composed (like a stub) + Proc::Async polished (improved error reporting, relaxed type constraints) + LoL assignment is now autovivifying + Semicolon/"rest of file" form of the MAIN sub implemented + Parsing for infixes like "$foo !and $bar" or "$foo !&& $bar" fixed + Coercion syntax for parameters: sub foo( Str(Any) $x ) { ... } + Str(Any) as a term now parses as a coercion type + Foo() works as a coercion type shortcut for Foo(Any) + Metaop "=" now respects the precedence of the op it's meta-ing + Enable term definitions via "my", e.g., "my \term:<∞> = Inf" + Added "polymod" method on numerical values + Made simple Str.trans / tr///, Str.subst about 20x faster + File test operators now follow symlinks on systems that support them + New method Rational.base-repeating, optional precision argument for Real.base + Blob.bytes now returns actualy byte size, even for non-byte blobs + "6;" at unit start is no longer a way to say "no strict;" + Anon variables in sink context warn now correctly + Buffer types can now be passed to C functions via NativeCall + C types like "long" that depend on the architecture are now handled correctly + NativeCall is now shipped with rakudo, because it is coupled too tightly + Allow "constant" and "has" declarations to be initialized with .= + Types constructed for mixins ("does" and "but") are now cached, giving a 10x speedup on repeated mixins of the same role to the same type and cutting CORE.setting size down (by 700KB on MoarVM, for example) + Made .^can(...) aware of submethods + Fixed a pre-compilation bug when a multi-method in a subclass was installed in a cloned proto-method inherited from the base class, then called at BEGIN time New in 2015.01 + New simple way of creating an object hash: :{} + Str.substr-rw was omitted before, it isn't anymore + The loop ^1000 optimization is working again + Pair.gist has been simplified (a => 42, rather than "a" => 42) + Exporting an Enum now also exports its values + Proper error handling for a placeholder that has already been used as non-placeholder in the same scope + Sub form of 'unique' introduced, 'uniq' deprecated + Supply.for deprecated in favour of Supply.from-list + All deprecated features will be removed with 6.0.0 (sometime in 2015) + Startup on the JVM has improved by 20% + Many improvements to Java interop for the JVM backend + Several precomp issues have been solved + Better error messages for die(Failure) + Fixed CATCH/CONTROL blocks in the program mainline + Substitution now supports assignment meta-op, e.g. s[\d+] += 2 + Many memory and CPU optimizations New in 2014.12 + Flakiness on OS X has been fixed + Support for Increase/Decrease, bless(*,...) removed, were deprecated 1+ year + Method FALLBACK implemented + $str ~~ s/// now returns a Match or list of Matches + Updated List smart-matching to latest design + $*DISTRO and $*KERNEL updated ($*DISTRO now actually report the Linux dist) + Most, if not all, signals are now supported everywhere (MoarVM only) + Configure.pl: Fixed check for outdated nqp-m; warn on missing --prefix + Optimizations of integer division and Rat construction + Added Metamodel::Primitives, to open up more meta-programming possibilities (publishing method caches, completely custom meta-objects, etc.) + Support for closure parameter signatures + Implemented chained sequences + Implemented longest literal LTM tie-breaker + Calling "close" on a Supply will now close all of its taps + Added "extension" method to IO::Path + Fixed bare "slurp", it was broken in 2014.11 or before New in 2014.11 + using a constant negative subscript now dies at compile time + better wording for runtime negative index failure + force calling method for <.foo> even if sub foo exists + fix tie-breaking issues with longest literal matching + make List.last-index non-lazy (as the whole list needs to be reified anyway) + introduce IO::Handle.slurp-rest for slurping rest from handle + method 'for' as an alias for 'map'. Map will stop flattening the list eventually, 'for' remains as it is now. + method 'unique' as a successor for 'uniq' + warn about clashing enum aliases, and also poison these aliases New in 2014.10 + unstrict mode now default with -e + use strict / no strict implemented (but -Mstrict does not work) + Implemented Supply.lines/words + Implemented IO::Handle.words + Updated chdir() to spec + Implemented indir( $dir,:test,{...} ) + Implemented tmpdir($dir) and homedir($dir) + Implemented IO::Path.all: "foo".IO.all() is True for r/w file + IO::Path.modified|accessed|changed now return Instant, according to spec + Fixed ordering issue with IO::Socket::Async + Str.words is now lazy by default + Str.words no longer returns the word if there is only one word: this behaviour was unspecced and apparently used internally only. This old behaviour is still available by specifying the :autoderef named parameter. + method .exists/.delete have been removed after 1+ year of deprecation + performance improvements in Str.trans and tr/// + fixed Str.trans and tr/// for anchored regexes + Bool.pick/roll (without parameter) now ~20x faster + Numeric.round (without parameter) now ~4x faster + Supply.more has been deprecated in favour of Supply.emit (as per spec) + Deprecations will now tell when they were introduced, and will give a release version in which the deprecated feature will be removed. New in 2014.09 + ./perl6 --profile for MoarVM, generates HTML profile output, including spesh/JIT info + Workaround OS X make bug for MoarVM + Make new LOLLY syntax the default + support for submethod DESTROY (MoarVM only) + optimizations to Str.words, Str.lines, IO.lines, chomp, and return + Str.lines and IO.lines take :eager for still faster performance + added experimental support for Proc::Async, MoarVM only for now + Promise.keep/break now default to True/False + support for S26-style declarative (#| and #=) comments + expectations are reported before result in test failures + bare 'say' is now a parse error + range *..* is now allowed (and means -Inf..Inf) + AST.Str now prints the correct source for operand ASTs + 'π' implemented as synonym for 'pi' + support for :temp/:let declarators in regexes + Reduced memory size of CORE.setting, improved startup time + startup (on Moar) 15% faster than p5 w/ Moose + fix issue with $*EXECUTABLE pointing to an non-existing interpreter on parrot New in 2014.08 + print file/line annotations for warnings also on moar and jvm + fixed reduce/infix function syntax [[&foo]] LIST and ITEM [&foo] ITEM + can now call exit() in END blocks without hanging or affecting END block execution + remove speed penalty of large ranges in character classes + make LF, FF, CR and NEL available as character names + fixed negated character lookup in regexes \C[...] + quote words syntax splits on breakable space only + duplicates in character classes warn now, like in accidently quoted items <[ '/' ]> + fixed (s)printf regression with "+" and " " flags + allow a DateTime to smartmatch against a Date + fix %a{5}:delete anomaly, "as Str" is your friend + die / note now say "Died" / "Noted" when not given anything + ∅ is finally recognized as the empty set + more work under the hood to get in line with S11 / S22 + Str.indent() now treats its arg as an Int where appropriate + Restructure the QAST classes + Add LoL candidates for postcircumfix:<[ ]> and postcircumfix:<{ }> + Pass --moar-options configuration to NQP's Configure + Add .new candidate for creating a Date from an Instant + Fail when a Boolean is used as the matcher for &grep, &grep-index, &first, &first-index, &last-index, and the corresponding methods + Implement cmp_ok in Test.pm + Add HyperWhatever / ** + Add method invoke as the preferred way to write what was method postcircumfix:<( )> + Warn when a Code object is coerced to Str + If the LOLLY envar is set, have (;;), [;;], etc., turn into LoLs. Otherwise, parsefail + Add SEQ(a; b) to emulate the old behavior of (a; b) + Make &infix: many times faster + NaN === NaN (but still NaN != NaN) + fix multi-dimensional slice assignment + Add .note() method to Mu New in 2014.07 + require and build parrot 6.6.0 + Cool.eval and eval() are now removed + assigning a single itemized hash to a hash is now DEPRECATED (my %h = {...}) + .hash now turns an itemized hash into a hash + added unpack directives "a" and "Z" + subbuf-rw specced and implemented + Supply.zip-latest specced and implemented + minute value is optional in Timezone offsets in DateTime.new(), also a colon to delimit hours/minutes is now optional + file copy and creation operations on the MoarVM now give default file permissions of 0666 + the tr/// operator is implemented and has the proper return value + improved string handling for MoarVM backend + fixed class A { my $.x = 42 } scoping on MoarVM + removed hack that kept (|)= & co from working + re-arranged infixish actions to support [[*]]= etc + optimized CompUnitRepo::Local::File + optimized takedispatcher to cleardispatcher + all backends now allow C pointer arithmetic and casting of pointers to Perl 6 types (this functionality is exposed by NativeCall) + made block inlining a level 2 optimization + small optimizations to number parsing + fixed Label.gist + fixed 'fail' so it also prints a backtrace + fixed a repeat until code-gen bug + added CompUnit.name and fixed .perl + removed hack for $Inf/$NaN: constants Inf/NaN are exposed since a while + made initial/max threads introspectable + naive implementation of IO.umask + make .WHICH also work on type objects + throw a X::Subscript::FromEnd for @foo[-1] + throw X::TypeCheck::Binding on all backends (was MoarVM only) New in 2014.06 + say/note now a little faster for single Str (which is most common) + an initial implementation of S11 (Compilation Units) is now available + .IO.{d|s|z} are now about 40% faster and return Failure if path doesn't exist + $*DISTRO now works correctly on OS X (with name "macosx") + $*KERNEL now works correctly on OS X (with name "darwin") + initial implementation of $*USER and $*GROUP + initial implementation of Supply.zip-latest + implement dummy Lock (for $lock.protect( {...} ) ) on parrot + @*INC now only contains elements for actually existing paths + more work on allowing slangs transparently (such as "v5") + IO::Socket::Async now also works on JVM + can close tap to stop listening on a socket + implement Supply.on_demand, for making on-demand supplies + fix race condition in async socket reading + can now also bind to dynamic variables + LAST phaser used to fire when not actually iterating, now fixed + (Set|Bag|Mix).pairs now return immutable Enums + (Set|Bag|Mix)Hash.pairs no longer allow changes feeding back + optimize :a(:$b) and attributive binding + optimize IO::Path.contents + optimize push, unshift, and comb + assorted optimizations to Junction construction and dispatch + optimize no-args case of @foo>>.bar + implement :42nd colonpair syntax + include correct version information in perl6-debug New in 2014.05 + asynchronous timers on MoarVM backend + added or updated many Supply methods: act, batch, categorize, Channel, classify, delay, elems, flat, grab, last, live, max, min, minmax, merge, migrate, Promise, reduce, reverse, rotor, sort, squish, stable, start, uniq, wait, zip + add list functionality to 'on', as with new S17 spec + added .Supply coercer + added IO::Notification.watch_path / IO::Path::watch which return a Supply of file system changes + added signal() which returns a Supply of Signals (such as SIG_HUP) + added IO::Socket::Async.connect, returns a Promise with a IO::Socket::Async + added IO::Socket::Async.send, returns a Promise with success / failure + added IO::Socket::Async.chars_supply, returns a Supply with chunks + added first-index, last-index, grep-index subs/methods + Pair.key was erroneously implemented "is rw" + added "subtest code, desc" to Test.pm (inspired by P5's Test::More) + added "throws_like" to Test.pm (formerly of Test::Util) + Test::Tap::tap_ok and throws_like are now 1 test (using subtest) + BagHash-- on non-existing key no longer fails (as per S02 spec change) + (Set|Bag|Mix)(|Hash) now have a .fmt method + deprecate $*OS, $*OSVER, $*VM, $*VM, $*PERL $*PERL... + added $*KERNEL, $*DISTRO, $*VM, $*PERL as full blown objects + .delta (by recent spec change) in Date/DateTime now instead spelled .later and .earlier + TimeUnit enum removed; string named and positional arguments used instead + optimized grep,grep-index,first,first-index,last-index with seperate candidates for Regex and Callable. + "use v5" is no longer a noop, but actually tries to load the "v5" module (soon available as part of Rakudo*) + implemented labeled loops and throwing of labels as payload + added various optimizations, like optimizing out %_ when unused New in 2014.04 + significant performance enhancement for MoarVM, spectest running 20%+ faster + S17 (concurrency) now in MoarVM (except timing related features) + winner { more @channels { ... } } now works + fixed pb with Parcelness of single element array slices with adverbs + implemented univals(), .unival and .univals (on MoarVM) + make .pick/.roll behave sanely on Enums + fixed Str.samespace and ss// + added .minpairs/.maxpairs on (Set|Bag|Mix)Hash + added Bag.kxxv + Capture.WHICH implemented so that identical Captures have the same .WHICH + Naive implementation of "is cached" trait on Routines + Hash.perl now randomizes key order, while Hash.gist sorts + NativeCall passes all its tests on all backends New in 2014.03 + Fix suggestions for unknown routines when specified with '&' + Match sigil in suggestions for unknown routines depending on specification + Improve suggestions for 'length' and 'bytes' being banned in Perl 6 + fixed for-loops to be properly lazy + Zop= now works + numerous Pod parsing and formatting improvements + uniname, uniprop, and unival implemented on MoarVM backend + @ as shortcut for @$, % as shortcut for %$ + improved "unable to deduce sequence" error message + duckmap, deepmap implemented + list infix reductions no longer flatten + X and Z meta ops treat [] as items + unary hyper subscripts (@array>>.[0]) now work + fixed problem with .=uniq and .=squish New in 2014.02 + $*INITTIME implemented + improved code generation for loops on the JVM backend + eager and lazy statement prefixes + statementlist-level for-loops are now assumed to be in sink context + improved unspace parsing + don't itemize make's ast argument + allow definition of custom postcircumfix operators + :allow in pod code blocks works now + Configure: git protocol is now configurable + smartmatching against an IO::Path does the right thing now + perl6-debug-* is now installed by rakudo; the user interface is still a module available from the ecosystem + lots of improvements for moarvm, such as client and server socket support and opening pipes/subprocesses + finished NativeCall support on the JVM New in 2014.01 + Use .narrow on Numeric to coerce to narrowest Type possible + Can now supply blocks with multiple arguments as sequence endpoints + rule no longer exists + The eval sub and method are now spelled EVAL + Method calls and hash/list access on Nil give Nil + No longer need to separate adverbs with comma in argument lists + div on parrot will now always round towards -Inf + Added support for MoarVM; passes >99% of the spectests that Rakudo JVM does + Fixed gather/take stack overflow bug in JVM backend + Fixed closure in regex bug on JVM + Fixed some line number reporting bugs on JVM + Optimized Enum($value) coercion + Regexes: Aliased assertions now properly create sub-captures + Regexes: Improved detection/reporting of null patterns + Implemented IO::Async::File.spurt (JVM only) + Implemented Setty.kv and Baggy.kv + Use a global ByteClassLoader rather than one per class. (JVM only) + Implement more parts of NativeCall for the JVM New in 2013.12 + The Whatever Star now works inside chain operators like comparisons + Private attributes from roles are now visible in the classes they apply to + Use invokedynamic in some places on the JVM. + Memory improvements in ListIter + Faster method List.combinations + Simple lookahead assertions in regexes are optimized + Regexes do less superfluous scanning New in 2013.11 + Many concurrency primitives harmonized with new S17, but still pretty fluid + Refactored build system that allows building rakudo on both backends in the same place + Order::Increase/Decrease are deprecated. Please use Order::Less/More. + Leading whitespace is ignored for :sigspace + Better null pattern detection in regexes + The "gethostname" function implemented + Warn when private attributes are a marked rw or readonly + "is DEPRECATED" trait now produces report when process finished + Parcel.rotate implemented + Performance optimization: unfold junctions in 'when' clauses + capitalize/.capitalize have been removed, as per docs/deprecations + improved run()/shell(), these return Proc::Status-objects now + The ... range operator can now be chained: 1,2,3 ... 10,15,20 ... 100 + various other bug fixes, optimisations and additional tests New in 2013.10 + postcircumfix {} and [] are now implemented as multi subs rather than multi methods. This should allow for better optimization in the future. + Add support for "is DEPRECATED", making it easy for early adopters to stay current. + Track multiple spec changes for various container classes. + Greatly reduce object creation during Regex parsing. + Various portability fixes. + qx// and run() now auto-quote correctly + Allow #`[...]-style comments in regexes + unlink() behaves like P5's, it deletes write-protected files on windows New in 2013.09 + candidate argument to bless removed (per spec change) + @a.VAR.name and %h.VAR.name implemented + The $var.++ and $var.() syntaxes work + Lots of improvements on the Set and Bag types + [op]() with relational operators vacuously return True + tr/// implemented + Sockets on JVM implemented + sleep(), sleep-time() and sleep-till() updated to spec New in 2013.08 + "is default" traits on variables, $/, $!, $_ are default Nil + "is dynamic" traits on variables, $/, $!, $_ are dynamic + "of TypeObject" trait on variables + .VAR.default/dynamic/of return the state of these traits + Assigning Nil, calling undefine() restores the default value + .WHAT more accurately returns a type object for specifically typed cases + Option --gen-nqp for ConfigureJVM.pl + Include file name in parser errors + Parse labels, tr/// (both don't do anything useful under the hood yet) + CALLER::<$var> now only works on dynamic variables, as per spec. + Improvements to Threads, including Channel and KeyReducer (JVM only) + Asynchronous file reading (JVM only) + Improved JVM interop, including 'use :from' (JVM only) + Fixed subroutine inlining on JVM + Fixed %*CUSTOM_LIB on JVM * Fixed sink context handling on JVM + Reimplementation of Buf as a role + Implemented Blob role + Implemented sized/encoded Buf/Blob types (buf8, blob8, utf8, etc.) + Str.encode now returns most specific appropriate type + "once" phaser fully implemented + Named parameters "with" and "as" on uniq/squish + "samewith()" for calling method on same dispatcher again + "will" variable trait partially implemented ($_ not set yet) + Interpolating strings into heredocs now dedents properly + Solved a slowdown when declaring custom operators + Improved P5-regexes (backslash sequences, code blocks) + Make type objects appear as Nil in non-scalar contexts + Placeholder variables $^A .. $^Z no longer allowed, as per spec + printf %d now supports bigints also on Parrot + my and our scoped methods no longer go into the method table + Implemented keybag(), KeyBag.push, KeyBag.categorize + Re-implemented hash iteration for a performance win + Various optimizations, code cleanups and error message enhancements New in 2013.07 + Huge progress in JVM backend (feature-wise almost on par with Parrot) + List.first is now lazy + unspace before argument lists is now supported + fixed handling of indented heredocs + basic support for threads and promises (JVM only) + improved sprintf and other formatting routines + keyof method for typed hashes to get key type + Hash.perl nows works for typed hashes + 'is parcel' and 'is default' traits (work in progress) + Parcel.new now works + slight optimization to join of many items + implemented canonpath for Win32 IO::Spec + implemented squish + made []:(kv|p|k|v) work according to spec + properly parse Pod formatting codes with brackets other than <...> + the POD_TO_TEXT_ANSI environment variable now leads to some formatting being applied by Pod::To::Text + declaration of multiple operators in a scope now generates much smaller serialized output + Int.round method now takes a scale argument + implemented Complex.ceiling, Complex.floor, Complex.round New in 2013.06 + JVM backend added - passes initial sanity tests + type captures in signature binder implemented + IO::Spec::Unix.canonpath made more efficient + IO::Handle methods gist, perl, path added + Int.msb and Int.lsb implemented + dir() is now lazy + lines($limit) now doesn't read an extra line + .^mro methods added to a few role metaclasses + $/ and $! now visible in eval/REPL + IO::Handle.copy moved to IO::Path.copy + .{} adverb combinations all implemented + :$ colonpair syntax implemented + 'my &foo; multi foo() { }' gives better error message + reduce() more aware of fiddliness + &first now returns Nil instead of failing + $*CWD and $*TMPDIR now contain IO::Path objects + REPL bug fixed when same line issued twice + pick/pop/push/roll/reverse/rotate/sort/classify/categorize now fail immediately if the list is infinite + categorize now returns a Hash, not a Parcel of Pairs + "undef" warning now refers to Any, not Mu + improved error messages for hash shapes + Hash.(classify|categorize) implemented + IO::Path.chmod implemented + IO::Path.succ and .pred implemented + syntax parser now allows a dot before hyper postfix + Str.succ added for codepoints \x2581..\x2588 + Cool.path implemented + sequences between 1-codepoint strings implemented + div and / fail with X::Numeric::DivisionByZero (rather than dying) + doing .perl on Rat with denominator 0 doesn't go into an infinite loop anymore + Capture.exists implemented New in 2013.05 + IO::Spec, a port of Perl 5's File::Spec + support for exporting things form EXPORT subroutine + ?-quantifier in regexes doesn't create arrays in the Match object anymore + speedup of repeated shifts of large lists and arrays by 70%+ + implemented Cool.lines + renamed IO to IO::Handle; IO is now a tag role, as per spec + simplify timezone handling + .Set and .Bag methods for List and Parcel + regex special characters can be used as delimiters + allow slice with :exists adverb on hashes … + .hash now accepts optional :type and :of named parameters + Make :exists and :delete up to spec … + fix for autoviv Typed hash problem + constant-fold infix:<~> + make decl and init of our-scoped arrays/hashes work + fix regex interpolation slowdown + fix exporting of subroutines + fix slurpy is-rw array-parameters + failed regex matches return Nil + add support for IO::Path:: + fix reporting of errors in gather/take. + added 125 extra opening/closing bracket-pairs + fix build failure on SPARC and PowerPC + underlying nqp layer supports parrot and JVM as backend, in preparation for JVM support in a future Rakudo release > more than 100 not listed changes New in 2013.04 + add Capture.Bool() + optimize getting size of numeric Range + for loops are eager again + improvements to DUMP() + wrap NQP objects in ForeignCode, allowing perl6 OO calls on them + improve some messages on parsefail. + add link and symlink to IO + reduce compile-time autothreading to avoid issues with !== + improve optimizer - caching, constants + fix List.ACCEPTS() for Whatever special case + bring 'require' closer to spec, esp. by taking paths + bring 'IO::Path' closer to spec + remove parrot dynops already provided as nqp ops + translate a dynop to nqp code + update from pir:: calls to nqp:: New in 2013.03 + Type names now gist as (Any) rather than Any() + Warn when pure expressions are used in sink context + Cool.substr(...) now correctly accepts whatever-star closures + Fix character class subtraction bugs + Correctly detect undeclared variables in regex assertions + :i now respected in character classes + Improved output of Rat.perl + Implemented shellwords postcircumfix (%h<< $x 'foo bar' >>) + User-defined circumfixes now parse a semilist rather than just an expression and handle whitespace correctly + Forbid null operators + Warn about leading 0 not indicating octal in Perl 6 + Fix some automatic end of statement on "}" parse bugs + Better error message on for(...) {} being interpreted as a function call + Array interpolations now properly do LTM + Respect :i in constructs like /:i <$var>/ + Autothread "none" and "all" junctions before "any" and "one" + Helpful error if you write "else if"/"elif" instead of "elsif" + Throw exception if a Range is used as a Range endpoint + Corrected argument order in IO.seek + Multi-dispatch now mostly implemented in NQP, not C + Fixed LEAVE (and thus UNDO/KEEP/temp) not firing in multis or upon 'next' in a for loop New in 2013.02 + "Did you mean ..." suggestions for symbol-not-found errors + Compile-time optimization of some cases of junctions in boolean context + Date and DateTime now support a .delta method + IO::Socket.get now works again with non-Unicode characters + $() now takes $/.ast into account + proper return value for smartmatching against a substitution + better error reporting when a parent class does not exist + constant folding for routines marked as 'is pure' + natively typed variables now work in the REPL + better error reporting in the REPL + writable $_ in -p and -e one-liner + speed up eqv-comparison of Bufs + warnings for useless use of (some) literals, variables and constant expressions in sink context + /../ and rx/.../ literals match against $_ in sink context + array variable interpolation into regexes New in 2013.01 + sink context; for-loops are now lazy by default + first mentioning a variable from outer scope and then redeclaring it in the same scope (my $a; { $a; my $a }) is now an error. + the long-deprecated "SAFE" setting has been removed + 'require' now works with indirect module names + restored socket read semantics to returning the requested number of bytes + $obj.Some::Role::meth() now passes the correct $obj + try/CATCH now returns Nil when the CATCH is triggered, rather than the exception; this brings it in line with try without a CATCH + whatever-star cases of splice now implemented + sequences with Junction endpoints now work + corrected precedence of various set operators + fixed binding of non-Any things into hashes and arrays + can now import multis with the same name from different modules, provided all dispatchers are onlystar New in 2012.12 + ~/.perl6/lib is gone from the default include path + fixed indent method's handling of empty lines + fixed .indent(*) + parse errors now formatted like in STD, with color + location of parse error now indicated with context + highwater algorithm implemented, greatly improving accuracy of parse error line numbers and locations in a range of cases + some parse errors now report what the parser was looking for at the time the parse failed + better errors for unmatched closing brackets and two terms in a row + uniq now has === semantics as specified, not eq semantics + junction auto-threader optimized and is an order of magnitude faster + implemented sub term: + implemented texas versions of the Set and Bag operators + good error for use of . to concatenate strings + flattening large lists of Parcels now happens in about half the time + adopted STD panic/sorry/worry model, meaning that we now keep parsing further and can report multiple issues in a range of cases + we now catch and complain about post-declared type names + variable redeclarations are now just a warning, not an error + a mention of an &foo that is never defined is now an error + fixed .perl output for a Pair with a Pair key + interpolation of undeclared arrays, hashes and functions now detected + { a => $_ } now correctly considered a block, not a hash as before New in 2012.11 + user-defined operators only affect the parser in the scope they are declared in + fixed pre-compilation of modules containing user-defined operators + implemented precedence related traits (equiv, looser, tighter, assoc) + Perl 6 grammar NFAs are pre-computed, saving some work on each invocation; this shaved around 10% off the time needed to run the spectests + redeclaring a class as a role now gives a better error + the < foo bar > syntax in regexes now respects :i + << ... >> now interpolates, respecting quoting and pairs + fix error reporting for not-found dynamic variables + many protos now have much narrower signatures + quote parsing implementation aligned with the approach STD uses + regexes and quotes have better support for user-selected delimiters + quote adverbs + heredocs + carry out IO::Path.dir deprecation + implement infix: + macro arguments now carry their lexical environment properly + postfix operators of the form '.FOO' take precedence over method calls + version control markers detected and gracefully complained over + INIT phasers now work as r-values + our ($x, $y) style declarations fixed + take and take-rw now evaluate to the taken value + implemented cando method on Routine + FIRST/NEXT/LAST can now be used in all types of loop (previously limited to for) + implemented operator adverbs + implemented :exists and :delete subscript adverbs and on hashes + implemented :p, :k, :v and :kv subscript adverbs on arrays and hashes + fixed shell words post-processing like << foo "bar $baz" >> + byte-order mark at the beginning of a file is now ignored + fixed bug that could lead to disappearing symbols when loading pre-compiled modules + Configure no longer passes --optimize to Parrot if --parrot-option is specified + deprecated current &foo semantics + fixed #`foo and friends at start of statementlist + simplify setting line number of compile-time exceptions + made :($a, $b) := \(1, 2) update $a and $b New in 2012.10 + :60[24, 59, 59] radix form + delegation to methods using the handles trait + fixed serialization of Buf + improved handling of :P5 regexes (more features, less bugs) + determining that an object lacks a method is usually now much faster + reduced memory usage of Match objects and optimized their construction a little + some code-generation improvements related to void context + implemented :dba('...') modifier in regexes + various error messages improved through use of :dba('...') in the Perl 6 grammar + implemented 'x' in pack + added $*CUSTOM-LIB + eval in a method can now see self, attributes and $?PACKAGE + each REPL line no longer implies a fresh GLOBAL + fixed some Pod parsing issues with Windows newlines + fixed interaction of :i and LTM (alternations and protoregexes now respect it) + import of custom meta-objects only affects the scope they are imported into + made <-> lambdas work + can now parse nested pairs of quote delimeters, like q{ foo q{ bar } baz } New in 2012.09.1 + is-prime and expmod + smart matching against Signature literals + binding to signatures in declarators + the is hidden and base traits + ability to set encoding on sockets temporarily removed (reverts to 2012.08 behavior) New in 2012.09 + class Iterable does not inherit from class Cool anymore + basic macro unquoting + basic support for m:P5/.../ regexes + support for indirect type names in routine and type declarations + compiler now built with QAST-based NQP, which generates better code, thus making the compiler a little faster + support for "is export" traits on constants + implemented Str.wordcase + can now write more complex proto subs and methods, using {*} to enter the dispatcher + tie-breaking with constraints now picks the first matching one rather than demanding they be mutually exclusive New in 2012.08 + tclc implemented + --> ReturnType in signatures and prefix type constraints of routine return types are honored + reduced memory usage at build time by around 35% - 40% + the argument to IO::Socket.recv is now interpreted as a number of characters + enum lists and arguments to parametric roles are now evaluated at compile time + switched to new internal AST and backend representations (QAST and PIRT) + removed deprecated routines Str.bytes and Str.lcfirst/&lcfirst + errors from traits now contain file name and line number + IO::File and IO::Dir have been removed + inliner has been improved and can inline a wider range of routines + simple implementation of the 'soft' pragma + fixed over-eager treatment of numeric literals as int rather than Int in cases where they appeared each side of an infix operator + detect circularities in module loading + sigilless variables in signatures when proeceed by | or \ + prevented blocks that declare variables turning into hash constructors + made pre-compilation complain if dependencies are not pre-compiled yet + fixed interpolation of double-quoted strings in regexes + fixed issue with Num.new not being friendly to subclassing + implemented handling of complex numbers in Str.Numeric New in 2012.07 + Deprecated SAFE.setting in favor of RESTRICTED.setting + Ranges can now interpolate in argument lists + The built-in meta-objects (such as Metamodel::ClassHOW) now inherit from Any + &open now supports :enc/:encoding + Exception.fail, .resumable and .resume + Changed &dir to return IO::Path objects, not strings + Deprecated .bytes, .ucfirst, and .lcfirst + &slurp now supports :bin + &spurt implemented + cleaned up Version implementation + fixed :s file test + recognize obosolete rand() and rand(N) forms at compile time + anonymous subset types 'subset :: of Int where { $_ > 0 }' New in 2012.06 + Rakudo is now compiled with the same regex engine as user-space regexes use + transitive longest-token matching in protoregexes + changed the output of Match.gist + string to number conversion now fails for non-numbers + string to number conversion now recognizes radix notation + string incrementation is now aware of more scripts + <|w> word boundary in regexes implemented + more errors from within the meta model now contain line number and file name + &push and &unshift functions can now autovivify + user-defined operators properly participate in LTM + Rakudo's C code is now compiled with optimization switches turned on + basic module loading tracing with the RAKUDO_MODULE_DEBUG=1 env variable + longest token matching with alternations + require with argument list + compile time errors in loaded modules now show a module loading backtrace + improved list and .map handling + can now use | to flatten a pair into an argument list as a named argument New in 2012.05 + meta ops //=, ||= and &&= now short-circuit properly + Failure objects don't blow up the REPL anymore + allow case insensitive regex matches without ICU in limited cases + %*ENV now propagates into subprocesses + RAKUDOLIB env variable supported in addition to PERL6LIB + -I and -M command line options + $?LINE and $?FILE variables + warnings now include line number from program, not from CORE.setting + reduction meta-operator on list-associative ops now has correct semantics + now have :th alias for :nth in Str.match + import collisions now report the name of the module that is to blame + ms// fixed + <$x> in regexes caches the compiled regex, which can be a big performance win + implemented temp and let + 'use' can now import by tag name + 'use' with positional arguments + lib.pm + updated calling conventions for traits + implemented fff flip-flop operator; improvements to ff form also + removed current directory from default library search path + 'import' works + symbols installed in EXPORT in all nested packages, not just UNIT::EXPORT + enumeration types can be used as roles + END phasers now run when program ends with exit or an exception + fix Rat.floor and .ceiling to work for large numbers + improved Rat stringification + Real is now a role, as it should be + implemented < foo bar baz > syntax for alternations in regexes + implemented <( and )> syntax for setting from/to of match in regexes + support for non-Int enums + basic support for Version literals + chmod now available as a function + roundrobin implemented + fixed a bug in precompilation of modules that use roles from other modules + basic implementation of pack and unpack + implemented substr-rw, which provides an l-value (assignable) substring + implemented <~~> (recursive call into self) syntax in regexes + 'LAZY' statement prefix New in 2012.04.1 + autvivification for arrays and hashes + more robust module precompilation + improved infrastructure for calling C code + $.foo style calls now contextualize correctly + &infix: now return members of the Order enum in all cases + --doc=format now loads Pod::To::format and uses it for rendering + 'lib/' is no longer in the default include path + improved Parameter.perl + add .changed, .modified and .accessed methods to IO + improved --help output + install precompiled test module for speedup + fixed printing of backtraces when regexes are in the call chain + case insensitive regex matches now also work for interpolated variables New in 2012.04 + 'defined' is now a listop instead of a prefix op + fixed :16('0d...') + implemented simple interpolation in names in type declarations (class ::(const) { }) + $=POD renamed to $=pod + fixed slicing of non-lists with infinite ranges + fixed accidental over-serialization, cutting ~300KB off each pre-compiled module + scalar positionals no longer treated as slices + implemented Routine.package + join will now always reify at least 4 elements of a list if possible + warnings now have line numbers + brought back Str.indent + ban declaring pseudo-packages, with a helpful error + a name followed by :: now returns .WHO, so Foo::<&bar> style lookups work + Exception.Bool now returns true + avoided re-parsing of longname, which speeds up the parse a bit overall + implemented MY, CALLER, OUTER, UNIT, CORE, SETTING and DYNAMIC pseudo-packages + implemented ::<$x> and ::{'$x'} style lookups + some small optimizations to various Str built-ins and MapIter + improved --doc output + added $*PERL + implemented IO::ArgFiles.slurp New in 2012.03 + updated to dyncall 0.7 + infix: now autothreads over junctions + more typed exceptions + pre-compiled modules/settings are now serialized, not re-built on load + startup time is now about 25% of what it once was + significant memory and time reduction (~40%) when pre-compiling modules/settings + BEGIN and CHECK now work in r-value context + constant declarator now works with non-literals on the RHS + implemented Set, Bag, KeySet and KeyBag types + implemented :exhaustive and :nth match adverbs + implemented ENTER, LEAVE, KEEP and UNDO phasers + implemented FIRST, NEXT and LAST phasers in for loops + implemented START phaser, including use of it in r-value context + implemented also syntax for adding traits inside a block/package + implemented macro declarations and quasi quotes (sans placeholders) + implemented anonymous enums + 'our multi' now dies (used to ignore the 'our') + implemented PRE and POST phasers + ~25% performance improvement to array indexing New in 2012.02 + catch duplicate accessor generation required of "has $.x; has @.x;" + many more typed exceptions thrown + undeclared attributes mentioned in signatures now caught at compile time + empty Buf is now False in boolean context + implemented + implemented // syntax + // can call a predeclared lexical regex x + conjugate is now called conj + enumeration values .gist to just the key, not the full name + in regexes fixed + implemented Match.make(...) method + better error reporting for improper use of nextsame and friends + initializers now parsed as part of a variable declarator + trailing whitespace now removed from Pod declarator blocks + List.tree made more useful + implemented rename and copy functions + ().pick and ().roll now return Nil + default MAIN usage message includes .WHY of the candidates + X::Base eliminated in favor of Exception + various range iteration fixes; Num ranges now produce Num lists + LHS of the xx operator is now thunked + can now declare state/constant/our in regexes (before, only :my worked) + improved backtraces + catch constructs that require an invocant but don't have one + catch uses of virtual method calls in submethods and attribute initializers + improved parsing and performance of reduction meta operators + Rat arithmetic now properly defaults to Num if the denominator is too big + FatRat implemented + implemented long forms of regex adverbs (e.g. "ignorecase" maps to "i") + fixed "but True" and "but False" + object hashes, with the my %h{SomeObjectType} syntax + implemented Int($x) style coercions + implemented Capture.perl New in 2012.01 + -c command line option re-implemented + take flattening bug fixed + duplicate named parameter names detected + fixed clone being too shallow with regard to containers + fixed negative modulo for bigint + better Routine.perl + .DEFINITE macro implemented + .^methods, .^attributes and .^parents now support :excl (the new default) and :all + Array.delete implemented + restored basic -n and -p functionality + improved parameter introspection + fixed operations on bigints when the first operand had been mixed in to + fixed multi-dispatch narrowness calculation for native types + binding to array and hash elements + added Order enumeration, and updated cmp and <=> to use it + adding various missing magicals, such as &?ROUTINE and ::?ROLE + accessor generation for my $.x and our $.x cases + fixed @x>>.() (hyper-invocation) + updated Complex.Str to match current spec + fixed eval to see GLOBAL properly + implemented 0 but Answer(42) style mix-ins + fixed various issues in scoping/handling of $/ + fixed usage of make in a regex (previously, only worked in action methods) + optimized Range.roll and Range.pick for large ranges + fixed non-numeric, no-Str ranges + fixed build on Cygwin + fixed regex backtracking into subrules and captures New in 2011.12 + improved protoregex support, including NFA caching + and (lookahead and lookbehind) + backslash sequences in character classes + fixed quantified captures and :r interaction bug + optimized match object construction, ListIter, substr and chomp + improved performance of send/get on sockets + optimizer detects missing private methods and simplifies calls (level 3 only) + fixed some issues when an array was assigned to itself, maybe using .= + implemented .wrap and .unwrap, plus wrap handles with a .restore method + implemented .trans on strings + unicode properties can be matched against in regexes + binding to @, % and & sigils now checks for the appropriate role + assignments to variables declared with the & sigil now checked for Callable + typed hashes, partial support for typed arrays + some parametric role fixes + can now use but operator with a type object + smartmatching of regexes against arrays and hashes + socket IO now implements .write and custom input line separators + implemented getc + implemented .WALK + implemented ff, ^ff, ff^ and ^ff^ + implemented .REPR macro + implemented Proxy class + some typed errors are now thrown from within the compiler + stubbed methods from roles now require those methods to be implemented + updated docs/ROADMAP + .WHICH now returns ObjAt objects + defining new operators New in 2011.11 + CATCH blocks are now much closer to spec + big integer support + basic protoregex support with NFA-driven LTM for some declarative constructs + correct default values for natively typed variables + fixed initialization of state variables + improved support for natively typed variables + catch more uses of undeclared variables + splice() is now implemented + uniq() is now implemented + several runtime errors now throw properly typed error objects + various performance improvements, for example to the X meta op and Str.succ + improved support for MAIN argument parsing + fixed lexicals/recursion bug + IO.copy is now implemented New in 2011.10 + operators and functions with native type arguments + detection of call to undefined routines at CHECK time + various optimizations: inlining of operators, CHECK time dispatch decisions + performance improvements of MapIter + support @$foo style derefencing/coercion + Exception.backtrace + eval() has stopped to catch exceptions New in 2011.09 + Rewritten meta object protocol and object storage + many speedups + Int, Num and Str are now far more lightweight + much more robust handling of infinite list + basic LoL (List of Lists) support + :U and :D type modifiers + protos and multis now conform to the new spec + improved enum support + basic 'constant' declarator + .WHAT and friends as macros + chrs sub and method + support for .gist + run() has been renamed to shell() to conform to current spec + hyper methods now descend into nested data structures + basic safe mode (through --seting=SAFE) + recording and reporting of test timings (tools/test_summary.pl) + Pod parsing and --pod=text option + basic support for .WHY + greatly improved BEGIN-time support + traits applied at BEGIN time for packages, routines and attributes + parametric roles reify types properly, fixing many bugs + better handling of type variables + support $?CLASS, which is generic in roles + support import/export of custom meta-objects for built in package declarators + custom meta-objects can override method dispatch + faster, allocation-free multi-dispatch cache + a custom BUILD does not suppress default values + undeclared attributes detected and reported at compile time + basic support for native int/num types on lexical variables + int/num as attributes are stored compactly in the object body New in 2011.07 + fractional powers of negative numbers now result in Complex numbers + obtain spectests from a specific branch of the 'roast' repo + fix bug that prevented build on systems with little RAM New in 2011.06 + added take-rw built-in + numerous build system improvements + assignment now evaluates arguments right-to-left New in 2011.05 release + added a call counter for builtins in Perl 6-level subroutines + gcd (greatest common divisor) and lcm (largest common multiple) operators + build system improvements + added --ignore-parrot-rev option to Configure.pl + Configure.pl now creates "config.status" file + fixed relational operators when used with NaN + implemented Int.base + speedup smart-matching against numbers and Str.comb with default arguments + added RAKUDO_SUBLOG environment var for tracking subroutine calls + overall performance speedups New in 2011.04 release + implemented Str.indent + A new, much simpler API and implemention of IO::Socket::INET + Unified error messages to use "Cannot" New in 2011.03 release + improved error message on type check failure in assignment + -n and -p command line options + Test.pm's skip() now has argument ordering consistent with todo() + implemented complex conjugation + more IO methods related to stat New in 2011.02 release + IPv6 support + more robust numeric exponentation + --ll-backtrace command line option for PIR level stack traces + future-proof for upcoming generational garbage collector in parrot + various constructs now return Nil + infix: implemented + infix:<^^> and infix: improved + negation metaoperator is now restricted to operators that return Bool New in 2011.01 release + faster subroutine calls (type cache) + 'handles RoleName' now works + Test.pm: s/done_testing/done/ + non-spec debugging pragma Devel::Trace + improved parsing of keyword boundaries + sped up .comb New in 2010.12 release + new .trans algorithm + fixed $*PID on MacOS X + don't register names of anon types + configuration improvements + updated Any functions + fix $*IN_DECL leakage + implemented Hash.hash + Temporal updates + Buf.decode fixed + open() fixed for binary flag New in 2010.11 release + now works with parrot on git + implemented qw// + 5x speedup of .trans + various improvements to Set + don't use deprecated charset ops anymore + Bool.Bool and Bool.so now return False + implemented &elems + improved error for Date.new(Str) + improvement on hyperoperators + indexings like .[0 .. *-1] work now New in 2010.10 release + True and False now stringify according to the specification + basic form of 'require' for run time module loading + warnings from the setting now produce line numbers in the users' program + local time zone available as $*TZ + more consistent line numbers from warnings + getting and setting attributes via introspection + implement samespace, ms// and ss/// + hyper operator invoving = can now modify their arguments + speed up Str.flip by over a factor of 100 New in 2010.09 release + new methods on IO concerning the modify and access time of files + S32::Temporal now completely implemented + Instants and Durations + speedup for slurp() and .reverse built-ins + various improvements to the Set type + revamp of series operator code, and adaption to new spec + implement ...^ up-to-but-excluding-series operator + allow :r and :ratchet modifiers on regex quoting constructs + Bool.pick + significantly improved enum implementation New in 2010.08 release + syntactic adverbs on substitutions, rx quotes and m//, e.g. '$x ~~ s:2nd/a/b/' + updated ROADMAP + speedups for integer operations + the Match class's .perl method now produces useful, roundtrippable Perl code + the MAIN subroutine can now parse short arguments + the cmp and <=> operators now work on more numeric types + the Buf class now has .pack and .unpack methods with partial functionality + numeric bitshift operators now have the correct precedence + smartmatch against True or False is now an error New in 2010.07 release + support for delegation via 'handles' + implemented binding with := and read-only binding with ::= + implement OS related built-ins like mkdir, cwd + improved diagnostics in Test.pm + basic binary IO, buffer encoding and decoding + magic $*ARGFILE file handle + more robust closures + multi-level Array and Hash element autovivification + perl6 --version now identifies the exact git sha1 and parrot version + implemented 'is rw' trait on classes + file tests now work through IO, ie. 'README'.IO ~~ :e + generic, multi-level Whatever-currying (eg grep !(* % 2), @list) + improved error reporting in many cases, especially multi-method dispatch + implemented backtracking into capturing groups and subrules + phasers refactored, they can now return results and see the setting + custom circumfix operators + basic .wrap and .unwrap implementation + weighted Hash.pick + .perl on custom classes now dumps attributes + Basic implementation of the ==> and <== feed operators + Int ~~ Num is no longer true, as per spec; use Numeric instead + Improvements to enumerations New in 2010.06 release + new list model with immutable iterators, lots of fixes to lists and arrays + variable interpolation into regexes + compile time Whatever currying for infix, prefix and postfix operators + autoprinting in the REPL shell + in @*INC, the current directory '.' now comes at the end, as in Perl 5 + basic Buf implementation: Str.encode/Buf.decode work for UTF-8 + proper Perl 6 match objects + Backtraces with Perl 6 subroutine names and line numbers + MAIN and USAGE subs + basic version of Str.trans + mix-ins with non-roles (5 but 'string') + @*ARGS is now read-write + IO::Socket::INET again works in CORE + hash and array slices have been greatly improved + basic support for callframe() and CallFrame type New in 2010.05 release + implemented lexical and anonymous classes and roles + manual pages are now installed + the .match method now understand the adverbs :c; :p, :nth, :x, :g, :ov + test reports with tools/test_summary.pl now record detailed timing information + many improvements to numeric handling + implemented S (sequential) meta operator + fixed placeholder parameters ($^a, $^b) + basic enum implementation + implemented List.classify + turned on an additional 47 test files + further improved error messages + implement zero-argument versions of many binary operators + basic interoperation with Perl 5 through the external Blizkost project New in 2010.04 release + interpolation of expression ending in postcircumfixes into double-quoted strings (for example "cards: @cards.sort()") + prefix and postfix hyper operators + multi subs now work properly when lexically scoped + implemented item assignment with tighter precedence than the comma operator + loading of .pm6 modules + Basic implementation of Numeric and Real roles + implementation of DateTime and Date built-in types + named regexes can be declared outside of grammars again + support for numbers with arbitrary radix, including fractional numbers (:16) + implemented fmt(), printf() note() and IO.getc built-in routines + infix meta operators now inherit the precedence of the modified operator + &[+] short name for infix operators + hash slices + signature literals + smart-matching against signatures + more consistent implementation of prefix:<|> for interpolating things into signatures + better error message on accidental usa of Perl 5 features such as << as bit shift operators, and catch many perl 5 magic variables + implemented type Cool + implemented anonymous classes and roles + implemented $*PID + method introspection works again + better error message for calling non-existent routine in a namespace + now run programs with the setting as an outer lexical scope, as per spec New in 2010.03 release + The trigonometric functions and the Rat class have received numerous updates, making them faster and more complete + .^parent now works again + The invocation logic has received various speedups + Hash creation has been optimized + Various improvement related to constant internal strings have led to slight speedups + .pick, .sort, .keys, .values, .kv, sprintf were reimplemented, ported from the old 'alpha' branch + The statement modifier for loop works again + Various parsing bugs have been sorted out; one having to do with closing curly braces at the end of a line not terminating the statement + .CREATE, .BUILDALL and .can in the OO system have received attention, some of it leading to mild speedups + $*PROGRAM_NAME and @*ARGS now work + Deferral works again (nextsame/nextwith/callsame/callwith) + Array.delete works again + Fixed .?, .+ and .* along with matching latest spec on .? + Switch untyped variables to default to Any instead of Mu + &foo lookup syntax works again (including for operators) + Various cases of eqv operator implemented + Make overriding postcircumfix:<( )> work again, this time per spec + Make junctions of code objects invokable again + Lazy implementation of the Z operator + Added back @*INC + Read-only %*ENV support + Grammars work again + Implemented regexes taking parameters + Implemented proto-regex declarations + Initial work on getting subset types working again + Add back many of the file test methods + Added docs/S11-Modules-proposal.pod documenting how we intend to handle modules through Rakudo * + First cut of locating and loading modules with a given version and/or authority, and in absence of a requirement selection of the latest version by default if multiple are available. + Many improvements to the series operator + Implemented 'need' and a first cut of 'import'; 'use' works in terms of them + Import is now into the lexical scope by default, as per spec + Removed requirement to hand-pre-compile .pm to .pir for use with 'use' + Improved multi-dispatch candidate not found errors to include details of the available candidates + Implemented 'use MONKEY_TYPING' + Many cases of smart-match work again + $x.Foo::bar() and $x.$y() work again + $.foo(1,2,3) works again + !, R, X and Z meta-operators work, albeit with some caveats + s/foo/bar/ and s[foo] = 'bar' substitution syntax implemented + Array.rotate added back + User defined operators (prefix, postfix, infix) working again + Many more small but important improvements to built-in types and functions + Various other bug fixes + ROADMAP updates New in 2010.02 release + The branch formerly known as 'ng' becomes the new master branch + The previous master branch is now Rakudo/alpha + NQP-RX replaces NQP in the Parrot Compiler Toolkit, enabling the source code of the compiler to be written in a subset of Perl 6 that is much more powerful, most importantly with regexes, as the name suggests + The revised Perl6/Grammar.pm is much closer to the canonical STD.pm + Regexes may declare contextual and lexical variables + Lazy lists and arrays are partly implemented + The object metamodel is largely written in NQP-RX instead of PIR + The name of the root of the object hierarchy is now Mu + The term 'undef' is gone, replaced by Nil, Mu or *.notdef depending on context + Builtin classes derive from Cool which derives from Any + The refactored source code is more compact and more easily extended + The number of spectests passed has reduced from a peak of 32731 in alpha to 24221, because porting the functionality to the new master is still ongoing + Release numbering changes from 'dash' to 'dot' delimiter to get on better with various package management systems New in 2010-01 release + Added method form of eval. + Implemented :s and :l file operators + Added functions for logarithms using $base + Refactored subroutine calls to use new Context structures in Parrot 2.0.0 New in 2009-12 release + Only minor maintenance was done because all attention was being given to the Rakudo/ng branch, bringing in the new nqp-rx bootstrap compiler New in 2009-11 release + Rakudo now uses Parrot's updated calling convention features + support unpacking of arrays, hashes and objects in signatures + changed .pick to use :replace instead of :repl + many core setting optimizations and bugfixes + IO::Socket.recv() has been extended to accept a parameter specifying the number of bytes which will be received + Rakudo now looks up %INC in the right namespace when loading libraries for foreign languages New in 2009-10 release + smolder reports for spectest runs + more Complex trig functions + pure Perl 6 implementation of the Complex type + some variants of the new series operator + correct construction of twigilled colonpairs + infix:, .pred and .succ for the Rat type + when configuring with --gen-parrot, pass --optimize to parrot's Configure.pl + moved more operators to the setting and thus made them overloadable + { %hash } now correctly constructs a hash, not a closure + new, faster low level Signature type + improved Signature introspection + new, much faster signature binder + improved various error messages related to signature binding + signature literals now supported + binding of named arguments to positional parameters + attributive parameters implemented + package blocks now run as immediate blocks, as per the spec + lexical variables declared outside of packages now visible inside them New in 2009-09 release + updates to numeric operators: infix(Int, Int) creates a Rat + Rat (rational) numbers + overloadable builtin operators + contextual variables + setting values in %*ENV now works + partial support for trigonometric functions of complex numbers + better handling of custom traits, many builtin traits moved to core setting + improved type dispatch for builtin operators, type coercions New in 2009-08 release + Rakudo must now be built from an installed parrot, and can be installed itself + separate Perl 6 meta class + introspection on roles + declaration of methods in the meta class by writing method ^newmethod($obj) + :tree options for parent class, attribute and role introspection + allow some custom postcircumfix:<( )> methods + moved more built-ins into the setting + implement operators infix: (divisibility test) and prefix [||] and [//] + updated ROADMAP in preparation for the Rakudo Star release + instead of throwing nasty parse errors, Rakudo now informs you that feed operators are not yet implemented + improved testing: planless testing with done_testing(); better diagnostic output from is() + the syntax for embedded comments has changed + embedded Pod comments are now recognized + support for defining traits and applying them to routines, classes and roles + "hides" trait (class A hides B { ... }), and "is hidden" + better handling of slurpy and optional in multi-dispatch + use of .?, .+ and .* with indirect calling form ($obj.+@cands) + .can improved; now returns something usable as an iterator + lastcall implemented New in 2009-07 release + extensive refactor of the multi dispatch code to get closer to the spec + better handling of named arguments in multi dispatch + operators and traits can be defined in the setting + basic implementation of the series and eqv operators + refatored trait code to match updated specification + implemented more cases of smartmatching against hashes + fixed state variables to work with //= and ||= initialization + improved testing: when Rakudo dies with 'Null PMC Access' it is never considered a success + implemented the :all flag to split which keeps captures + added List.rotate builtin + nextwith and callwith now also work properly with methods + take() without outer gather now merely warns + introspection of roles and attributes New in 2009-06 release + refactored and corrected object initialization (BUILD/CREATE) + attributes initilizations can now use attributes defined earlier + method calls are now faster + basic safe mode that forbids IO and execution of external programs + implemented meta operators for user defined operators + initial implementation of Temporal (date/time related objects) + type checking of implicit return values + improved introspection methods + cleaned up IO methods + improved "is export" handling for modules and setting + automatically transcode to iso-8859-1 for faster parsing when possible + refactored and corrected assignment, .succ, .pred, C<++>, C<-->, postcircumfix:<[ ]>, Whatever + "module Foo;" now allows statements before it + improved Unicode string handling + better support for Str increment/decrement in Unicode ranges + many performance improvements New in 2009-05 release + updated docs/ROADMAP + basic support for custom operators + operators can now be referenced as &infix:<+> + meta operator support for custom operators + cross-language library loading + stack traces now include source file name and line number + implemented Regex type + .WALK (parent classes in configurable order) + .name method on routines + refactored enums, thereby fixing many enum related bugs + fixed namespace of eval()ed code + implemented parallel dispatch (@objects>>.methods) + initial support for «...» quotes + text files now default to utf8 encoding + fixes to Match.perl and Match.chunks + implemented 'constant name = $value' + documented build dependencies + grep() accepts general matcher, things like @list.grep(Int) work + trigonometric functions (sin, cos, ...) now available via 'use Num :Trig' + qx{} quotes now work (except on Windows) + hyper-operators on hashes now work (%a >>+<< %b) + initial implementation of $foo.@bar + refactored wrap and unwrap to work with candidate lists; fixes some bugs + refactored/improved callsame and callwith, and added nextsame and nextwith (only work for dispatches of the form $foo.@bar and with wrap so far) + partial implementation of .^parents and .^methods + can initialize attributes in terms of others + many other bug fixes and performance enhancements New in 2009-04 release (#16, "Bratislava") + wrap and unwrap for subroutines + calling a method on a Whatever star generates a closure + 1+*, *+1 and others generate closures (*-1 missing) + Associative, Positional and Callable are now parametric roles + typed arrays and hashes + parametric role subtyping (R[T1] ~~ R[T2] where T1 ~~ T2) + .invert and .push on Hashes + enforce return types of subroutines (partial implementation) + parallel testing + Configure.pl now supports passing options to parrot's Configure + support for lexical subroutines and multis + implemented \c[character name] in double quoted strings and regexes + implemented Perl 5 regexes + rx/.../ regex quoting + sockets support has been added (IO::Socket) + regex patterns may now be quantified by a separator regex + moved many methods to the setting + exporting and importing by tags, support :DEFAULT export tag + implemented START blocks + implemented roots builtin + implemented .ast on Match objects + added Match.caps and Match.chunks + split() now supports limits in all cases + prefix:<=> and the "fish operator" ( =<> ) are now gone + .readline is now .get + roles are now punned on any method call on the role + many other bug fixes New in 2009-03 release (#15, "Oslo") + implemented $*PROGRAM_NAME magical variable + outer lexicals are now visible in eval() + next, last etc. work in grep() + added R metaoperator + add an initial draft of Match.perl + refactor Grammar and Match class hierarchy + fix if/unless/while/until/for/... on line after close curlies + add Q quoting, including Q:PIR + added "state" variables + //= fixed to short-circuit, and added short-circuiting &&= and ||= + multi-subs now have the Multi type and have a .candidates method + multi-method dispatch now looks up the class hierarchy + various fixes to using roles as type constraints + support bare sigils in signatures + more methods and functions moved to (Perl 6) setting + many other bug fixes New in 2009-02 release (#14, "Vienna") + first release independent of Parrot releases + passing 7076 spectests (+796 since 2009-01 release) + build and use fakecutable (perl6.exe) by default + redesigned build, configuration, and test subsystems + add settings/ directory for builtins written in Perl 6 (was "prelude") + improve diagnostics in Test.pm + allow anonymous classes via C<::> + re-use existing parameterized roles instead of creating new ones + roles now pun classes when .new is called on them + 'proto' now marks all same-named routines as 'multi' + XopX is now Xop + implement <-> (rw) pointy blocks + added min= and max= metaoperators + many many bugfixes + publish release schedule + documentation improvements