rakudo-2015.11/CREDITS000644 000765 000024 00000016342 12573576073 016166 0ustar00williamcoledastaff000000 000000 =pod Following in the steps of other open source projects that eventually take over the world, here is the partial list of people who have contributed to Rakudo and its supporting works. It is sorted by name and formatted to allow easy grepping and beautification by scripts. The fields are: name (N), email (E), web-address (W), description (D), Subversion or GitHub username (U) and snail-mail address (S). Thanks, The Rakudo Team PS: Yes, this looks remarkably like the Linux CREDITS format PPS: This file is encoded in UTF-8 ---------- N: Alberto Manuel Brandao Simoes U: ambs E: ambs@cpan.org S: Braga, Portugal W: http://alfarrabio.di.uminho.pt/~albie/ N: Alex Elsayed U: eternaleye E: eternaleye@gmail.com N: Alexander Moquin U: Mouq N: Allison Randal D: Parrot Architect (0.4.6...) E: allison@parrot.org U: allison N: Ahmad M. Zawawi U: azawawi E: ahmad.zawawi@gmail.com D: Rakudo builtins, win32 patches N: Andrew Egeler U: retupmoca N: Andrew Whitworth E: wknight8111@gmail.com U: Whiteknight N: Andy Lester E: andy@petdance.com W: http://perlbuzz.com/ S: McHenry, IL, USA U: petdance N: Arne Skjærholt U: arnsholt E: arnsholt@gmail.com U: ask N: Ask Bjørn Hansen D: Keeps us running E: ask@develooper.com N: Audrey Tang U: au E: audreyt@audreyt.org D: Pugs, a Perl6->Parrot implementation. N: Вячеслав Матюхин U: mmcleric E: me@berekuk.ru D: Whatever-currying, colonpair fixes N: Bart Wiegmans U: bdw U: brrt E: bartwiegmans@gmail.com D: Hack MoarVM JIT stuff N: Bernhard Schmalhofer U: bernhard E: Bernhard.Schmalhofer@gmx.de N: Bob Rogers D: Random small bug fixes E: rogers-perl6@rgrjr.dyndns.org U: rgrjr N: Brent Laabs U: labster E: bslaabs@gmail.com N: Bruce Gray U: util E: bruce.gray@acm.org N: Bruce Keeler U: bkeeler D: variable interpolation into regexes N: Bryan C. Warnock D: The First Perl 6 Summarizer D: Little things here and there in pre-Parrot days. D: And, yes, {sigh}, *that* Warnock. E: bwarnock@raba.com N: Carl Mäsak E: cmasak@gmail.com U: masak N: Carlin Bingham E: cb@viennan.net U: carbin N: Chip Salzenberg D: Release manager emeritus D: Architect emeritus (0.1.2-0.4.5) U: chip E: chip@pobox.com N: Chris Davaz D: Rakudo builtins E: cdavaz@gmail.com N: Chris Dolan U: cdolan D: Rakudo patches E: cdolan@cpan.org N: Chris Fields U: cjfields D: Rakudo patches N: Christian Bartolomäus U: usev6 U: bartolin E: bartolin@gmx.de N: Christoph Otto a.k.a. cotto U: cotto E: christoph@mksig.org N: chromatic U: chromatic E: chromatic@wgz.org W: http://wgz.org/chromatic/ N: Colin Kuskie U: colink E: ckuskie@sterling.net N: Cory Spencer U: cspencer D: Rakudo builtins E: cspencer@sprocket.org N: Curtis 'Ovid' Poe U: Ovid D: docs/test cleanups/Makefile fixes D: Rename 'pbc_to_c' to 'pbc_to_exe' E: ovid@cpan.org N: Dan Sugalski U: dan D: Architect emeritus (0.0.1-0.1.1) E: dan@sidhe.org W: http://www.sidhe.org/~dan/blog/ N: David Romano D: PGE tests and fixes E: david.romano+p6i@gmail.com N: Dino Morelli D: PGE tests E: dmorelli@reactorweb.net N: Donald Hunter U: donaldh E: donald@sealgair.com N: Elise U: rightfold U: eli-se E: rightfold@gmail.com N: Elizabeth Mattijsen U: lizmat E: liz@dijkmat.nl N: Faye Niemeyer U: ShimmerFairy N: Florian Ragwitz U: rafl U: flora E: rafl@debianforum.de W: http://www.tu-chemnitz.de/~rafl/ S: Chemnitz, Germany N: François Perrad E: francois.perrad@gadz.org W: http://fperrad.googlepages.com/home U: fperrad N: Geoff Broadwell U: japhb E: geoff@broadwell.org U: gregor N: Gregor N. Purdy E: gregor@focusresearch.com S: Sunnyvale, CA U: ingy N: Ingy döt Net E: ingy@ingy.net W: http://ingy.net/ S: Seattle, WA, USA D: Make is() work like Perl 5; add .pm6 to extensions searched. N: JD Horelick U: jdhore E: jdhore1@gmail.com N: James E Keenan (Jim) E: jkeenan@cpan.org U: jkeenan W: http://thenceforward.net/parrot/ S: Brooklyn, NY, USA N: Jarkko Hietaniemi U: jhi E: jhi@iki.fi N: Justin DeVuyst U: jdv79 N: Jason Gloudon N: Jeff Goff D: Parrot Release Manager Emeritus (0.2..0.4) E: drforr@pobox.com U: drforr N: Jeff Horwitz E: jeff@smashing.org U: jhorwitz N: Jerry Gay U: particle E: Jerry.Gay@gmail.com S: Seattle, WA, USA N: Jesse Vincent U: jesse E: jesse@fsck.com N: John Harrison U: __ash__ E: ash@greaterthaninfinity.com N: Jonathan Scott Duff U: perlpilot U: PerlJam E: duff@pobox.com N: Jonathan "Duke" Leto U: leto U: dukeleto E: jonathan@leto.net W: http://leto.net S: Portland, OR N: Jonathan Stowe U: RabidGravy N: Jonathan Worthington U: jnthn E: jnthn@jnthn.net W: http://www.jnthn.net/ N: Joshua Gatcomb N: Julian Albo U: julianalbo E: julian.notfound@gmail.com N: Kevin Tew U: tewk E: tewk@tewk.com N: Klaas-Jan Stol U: kjs E: parrotcode@gmail.com N: Kodi Arfer U: Kodi W: http://arfer.net N: Kyle Hasselbacher E: kyleha@gmail.com U: KyleHa U: kyle D: Test.pm improvements, ticket testing N: Larry Wall E: larry@wall.org U: TimToady N: Leopold Toetsch U: leo D: Patchmonster & release manager emeritus (0.0.13 - 0.4.5) E: lt@toetsch.at S: Herrnbaumgarten, Austria N: Luke Palmer E: luke@luqui.org U: luqui N: Mark Glines U: infinoid E: mark@glines.org S: South Lake Tahoe, CA, USA N: Mark Grimes E: mgrimes@cpan.org N: Martin Berends E: mberends@autoexec.demon.nl D: Rakudo patch(es) N: Matt Diephouse U: mdiep E: matt@diephouse.com N: Michael Schroeder U: mls D: Exception handling E: mls@suse.de N: Moritz Lenz E: moritz@faui2k3.org U: moritz D: Test infrastructure, tests, general Rakudo hacking N: Nicholas Clark U: nicholas E: nick@ccl4.org N: Notfound E: julian.notfound@gmail.com N: Nuno 'smash' Carvalho U: smash E: mestre.smash@gmail.com N: Patrick Abi Salloum U: patrickas E: patrick.abisalloum@gmail.com N: Patrick R. Michaud U: pmichaud D: Perl 6 (Rakudo Perl) lead developer, pumpking E: pmichaud@pobox.com N: Paul Cochrane U: paultcochrane E: paultcochrane@gmail.com N: Pepe Schwarz U: psch U: peschwa E: peschwa@gmail.com N: Peter Gibbs U: petergibbs E: peter@emkel.co.za N: Piers Cawley U: pdcawley D: The Second Perl 6 Summarizer after Bryan C. Warnock E: pdcawley@bofh.org.uk W: http://www.bofh.org.uk:8080/ N: Reini Urban U: rurban E: rurban@cpan.org D: cygwin fixes N: Rob Hoelz U: hoelzro E: rob@hoelz.ro N: Robert Spier D: Keeps us running U: robert E: robert@perl.org N: Shrivatsan Sampathkumar U: isBEKaml E: nastavs@gmail.com N: Simon Cozens U: simon E: simon@simon-cozens.org N: Solomon Foster U: colomon E: colomon@gmail.com N: Stefan O'Rear U: sorear E: stefanor@cox.net N: Stéphane Payrard D: Various code fixes and improvements N: Stephen Weeks U: tene D: Minor Rakudo patches E: tene@allalone.org N: Tadeusz Sośnierz U: tadzik E: tadzikes@gmail.com N: Timo Paulssen U: timo U: timotimo E: timonator@perpetuum-immobile.de N: Timothy Totten U: novus D: Temporal (DateTime/Date) modifications E: supernovus@gmail.com W: http://huri.net/ N: Tobias Leich U: FROGGS E: email@froggs.de N: Tyler Curtis U: tcurtis D: $*ARGFILES E: tyler.l.curtis@gmail.com N: Ujwal Reddy Malipeddi E: ujwalic@gmail.com D: Rakudo patch N: Vasily Chekalkin E: bacek@bacek.com D: Core and Rakudo patches N: Will "Coke" Coleda U: coke E: will@coleda.com N: Zach Morgan E: zpmorgan@gmail.com D: Rakudo patch N: Nick Logan U: ugexe E: nlogan@gmail.com N: Leon Timmermans U: leont E: fawaka@gmail.com =cut rakudo-2015.11/Configure.pl000644 000765 000024 00000032742 12621370005 017403 0ustar00williamcoledastaff000000 000000 #! perl # Copyright (C) 2009 The Perl Foundation use 5.008; use strict; use warnings; use Text::ParseWords; use Getopt::Long; use File::Spec; use Cwd; use lib 'tools/lib'; use NQP::Configure qw(sorry slurp cmp_rev gen_nqp read_config fill_template_text fill_template_file system_or_die verify_install); my $lang = 'Rakudo'; my $lclang = lc $lang; my $uclang = uc $lang; my $win = $^O eq 'MSWin32'; my $slash = $win ? '\\' : '/'; MAIN: { if (-r 'config.default') { unshift @ARGV, shellwords(slurp('config.default')); } my %config = (perl => $^X); my $config_status = "${lclang}_config_status"; $config{$config_status} = join ' ', map { qq("$_") } @ARGV; my $exe = $NQP::Configure::exe; my %options; GetOptions(\%options, 'help!', 'prefix=s', 'sysroot=s', 'sdkroot=s', 'backends=s', 'no-clean!', 'gen-nqp:s', 'gen-moar:s', 'moar-option=s@', 'git-protocol=s', 'make-install!', 'makefile-timing!', 'git-depth=s', 'git-reference=s', ) or do { print_help(); exit(1); }; # Print help if it's requested if ($options{'help'}) { print_help(); exit(0); } unless (defined $options{prefix}) { my $default = defined($options{sysroot}) ? '/usr' : File::Spec->catdir(getcwd, 'install'); print "ATTENTION: no --prefix supplied, building and installing to $default\n"; $options{prefix} = $default; } $options{prefix} = File::Spec->rel2abs($options{prefix}); my $prefix = $options{'prefix'}; my @known_backends = qw/moar jvm/; my %known_backends = map { $_, 1; } @known_backends; my %letter_to_backend; my $default_backend; for (keys %known_backends) { $letter_to_backend{ substr($_, 0, 1) } = $_; } my @backends; my %backends; if (defined $options{backends}) { $options{backends} = join ",", @known_backends if uc($options{backends}) eq 'ALL'; for my $b (split /,\s*/, $options{backends}) { $b = lc $b; if ($b eq 'parrot') { die "The Parrot backend has been suspended.\n" . "Please use Rakudo 2015.02 (which still supports parrot), or the MoarVM backend instead\n"; } unless ($known_backends{$b}) { die "Unknown backend '$b'; Supported backends are: " . join(", ", sort keys %known_backends) . "\n"; } $backends{$b} = 1; push @backends, $b; $default_backend ||= $b; } unless (%backends) { die "--prefix given, but no valid backend?!\n"; } } else { for my $l (sort keys %letter_to_backend) { if (-x "$prefix/bin/nqp-$l" || -x "$prefix/bin/nqp-$l.exe" || -x "$prefix/bin/nqp-$l.bat") { my $b = $letter_to_backend{$l}; print "Found $prefix/bin/nqp-$l (backend $b)\n"; $backends{$b} = 1; push @backends, $b; $default_backend ||= $b; } } if (exists $options{'gen-moar'}) { push @backends, 'moar' unless $backends{moar}; $backends{moar} = 1; $default_backend ||= 'moar'; } unless (%backends) { die "No suitable nqp executables found! Please specify some --backends, or a --prefix that contains nqp-{p,j,m} executables\n\n" . "Example to build for all backends (which will take a while):\n" . "\tperl Configure.pl --backends=moar,jvm --gen-moar\n\n" . "Example to build for MoarVM only:\n" . "\tperl Configure.pl --gen-moar\n\n" . "Example to build for JVM only:\n" . "\tperl Configure.pl --backends=jvm --gen-nqp\n\n"; } } # Save options in config.status unlink('config.status'); if (open(my $CONFIG_STATUS, '>', 'config.status')) { print $CONFIG_STATUS "$^X Configure.pl $config{$config_status} \$*\n"; close($CONFIG_STATUS); } $config{prefix} = $prefix; $config{sdkroot} = $options{sdkroot} || ''; $config{sysroot} = $options{sysroot} || ''; $config{slash} = $slash; $config{'makefile-timing'} = $options{'makefile-timing'}; $config{'stagestats'} = '--stagestats' if $options{'makefile-timing'}; $config{'cpsep'} = $win ? ';' : ':'; $config{'shell'} = $win ? 'cmd' : 'sh'; $config{'runner_suffix'} = $win ? '.bat' : ''; my $make = 'make'; if ($win) { my $has_nmake = 0 == system('nmake /? >NUL 2>&1'); my $has_cl = `cl 2>&1` =~ /Microsoft Corporation/; my $has_gmake = 0 == system('gmake --version >NUL 2>&1'); my $has_gcc = 0 == system('gcc --version >NUL 2>&1'); if (-x "$prefix/bin/nqp-m.bat" && ($_ = `$prefix/bin/nqp-m.bat -e "print(nqp::backendconfig())"`)) { $make = $_; } elsif ($has_nmake && $has_cl) { $make = 'nmake'; } elsif ($has_gmake && $has_gcc) { $make = 'gmake'; } } for my $target (qw/common_bootstrap_sources moar_core_sources/) { open my $FILELIST, '<', "tools/build/$target" or die "Cannot read 'tools/build/$target': $!"; my @lines; while (<$FILELIST>) { chomp; push @lines, " $_\\\n"; } close $FILELIST; $config{$target} = join '', @lines; } open my $MAKEFILE, '>', 'Makefile' or die "Cannot open 'Makefile' for writing: $!"; print $MAKEFILE "\n# Makefile code generated by Configure.pl:\n"; fill_template_file('tools/build/Makefile-common-macros.in', $MAKEFILE, %config); my @prefixes = map substr($_, 0, 1), @backends; my $launcher = substr($default_backend, 0, 1) . '-runner-default'; print $MAKEFILE "all: ", join(' ', map("$_-all", @prefixes), $launcher), "\n"; print $MAKEFILE "install: ", join(' ', map("$_-install", @prefixes), $launcher . '-install'), "\n"; print $MAKEFILE "clean: ", join(' ', map "$_-clean", @prefixes), "\n"; print $MAKEFILE "\t\$(RM_F) perl6", $config{'runner_suffix'},"\n\n"; for my $t (qw/test spectest coretest localtest stresstest/) { print $MAKEFILE "$t: ", join(' ', map "$_-$t", @prefixes), "\n"; } fill_template_file('tools/build/Makefile-common-rules.in', $MAKEFILE, %config); # determine the version of NQP we want my ($nqp_want) = split(' ', slurp('tools/build/NQP_REVISION')); $options{'gen-nqp'} ||= '' if exists $options{'gen-moar'}; my %binaries; my %impls = gen_nqp($nqp_want, prefix => $prefix, backends => join(',', sort keys %backends), %options); my @errors; my %errors; if ($backends{jvm}) { $config{j_nqp} = $impls{jvm}{bin}; $config{j_nqp} =~ s{/}{\\}g if $win; my %nqp_config; if ( $impls{jvm}{ok} ) { %nqp_config = %{ $impls{jvm}{config} }; } elsif ( $impls{jvm}{config} ) { push @errors, "nqp-j is too old"; } else { push @errors, "Unable to read configuration from NQP on the JVM"; } my $bin = $impls{jvm}{bin}; if (!@errors && !defined $nqp_config{'jvm::runtime.jars'}) { push @errors, "jvm::runtime.jars value not available from $bin --show-config."; } $errors{jvm}{'no gen-nqp'} = @errors && !defined $options{'gen-nqp'}; unless (@errors) { my $java_version = `java -version 2>&1`; $java_version = $java_version =~ /(?[\d\._]+).+\n(?\S+)/ ? "$+{'n'} $+{'v'}" : 'no java version info available'; print "Using $bin (version $nqp_config{'nqp::version'} / $java_version).\n"; $config{'nqp_prefix'} = $nqp_config{'jvm::prefix'}; $config{'nqp_jars'} = $nqp_config{'jvm::runtime.jars'}; $config{'bld_nqp_jars'} = join( $config{'cpsep'}, map { $config{'sysroot'} . $_ } split( $config{'cpsep'}, $nqp_config{'jvm::runtime.jars'} ) ); $config{'nqp_classpath'} = $nqp_config{'jvm::runtime.classpath'}; $config{'j_runner'} = $win ? 'perl6-j.bat' : 'perl6-j'; fill_template_file('tools/build/Makefile-JVM.in', $MAKEFILE, %config); } } if ($backends{moar}) { $config{m_nqp} = $impls{moar}{bin}; $config{m_nqp} =~ s{/}{\\}g if $win; my %nqp_config; if ( $impls{moar}{ok} ) { %nqp_config = %{ $impls{moar}{config} }; } elsif ( $impls{moar}{config} ) { push @errors, "The nqp-m binary is too old"; } else { push @errors, "Unable to read configuration from NQP on MoarVM"; } $errors{moar}{'no gen-nqp'} = @errors && !defined $options{'gen-nqp'}; unless ($win) { $config{'m_cleanups'} = " \$(M_GDB_RUNNER) \\\n \$(M_VALGRIND_RUNNER)"; $config{'m_all'} = '$(M_GDB_RUNNER) $(M_VALGRIND_RUNNER)'; $config{'m_install'} = ' $(PERL) tools/build/create-moar-runner.pl "$(MOAR)" perl6.moarvm $(DESTDIR)$(PREFIX)/bin/perl6-gdb-m "$(PERL6_LANG_DIR)/runtime" "gdb" "$(M_LIBPATH)" "$(PERL6_LANG_DIR)/lib" "$(PERL6_LANG_DIR)/runtime"' . "\n" . ' $(PERL) tools/build/create-moar-runner.pl "$(MOAR)" perl6.moarvm $(DESTDIR)$(PREFIX)/bin/perl6-valgrind-m "$(PERL6_LANG_DIR)/runtime" "valgrind" "$(M_LIBPATH)" "$(PERL6_LANG_DIR)/lib" "$(PERL6_LANG_DIR)/runtime"'; } unless (@errors) { print "Using $config{m_nqp} (version $nqp_config{'nqp::version'} / MoarVM $nqp_config{'moar::version'}).\n"; $config{'perl6_ops_dll'} = sprintf($nqp_config{'moar::dll'}, 'perl6_ops_moar'); # Add moar library to link command # TODO: Get this from Moar somehow $config{'moarimplib'} = $win || $^O eq 'darwin' ? $nqp_config{'moar::libdir'} . '/' . $nqp_config{'moar::sharedlib'} : ''; fill_template_file('tools/build/Makefile-Moar.in', $MAKEFILE, %config, %nqp_config); } } if ($errors{jvm}{'no gen-nqp'} || $errors{moar}{'no gen-nqp'}) { my @options_to_pass; push @options_to_pass, "--gen-moar" if $backends{moar}; push @options_to_pass, "--gen-nqp" unless @options_to_pass; my $options_to_pass = join ' ', @options_to_pass; my $want_executables =$backends{moar} ? ' and MoarVM' : ''; my $s1 = @options_to_pass > 1 ? 's' : ''; my $s2 = $want_executables ? 's' : ''; push @errors, "\nTo automatically clone (git) and build a copy of NQP $nqp_want,", "try re-running Configure.pl with the '$options_to_pass' option$s1.", "Or, use '--prefix=' to explicitly specify the path where the NQP$want_executables", "executable$s2 can be found that are use to build $lang."; } sorry(@errors) if @errors; my $l = uc substr($default_backend, 0, 1); print $MAKEFILE qq[\nt/*/*.t t/*.t t/*/*/*.t: all\n\t\$(${l}_HARNESS_WITH_FUDGE) --verbosity=1 \$\@\n]; close $MAKEFILE or die "Cannot write 'Makefile': $!"; unless ($options{'no-clean'}) { no warnings; print "Cleaning up ...\n"; if (open my $CLEAN, '-|', "$make clean") { my @slurp = <$CLEAN>; close($CLEAN); } } if ($options{'make-install'}) { system_or_die($make); system_or_die($make, 'install'); print "\n$lang has been built and installed.\n"; } else { print "\nYou can now use '$make' to build $lang.\n"; print "After that, '$make test' will run some tests and\n"; print "'$make install' will install $lang.\n"; } exit 0; } # Print some help text. sub print_help { print <<"END"; Configure.pl - $lang Configure General Options: --help Show this text --prefix=dir Install files in dir; also look for executables there --sdkroot=dir When given, use for searching build tools here, e.g. nqp, java etc. --sysroot=dir When given, use for searching runtime components here --backends=jvm,moar Which backend(s) to use (or ALL for all of them) --gen-nqp[=branch] Download and build a copy of NQP --gen-moar[=branch] Download and build a copy of MoarVM to use --moar-option='--option=value' Options to pass to MoarVM's Configure.pl --git-protocol={ssh,https,git} Protocol used for cloning git repos --git-depth= Use the --git-depth option for git clone with parameter number --git-reference= Use --git-reference option to identify local path where git repositories are stored For example: --git-reference=/home/user/repo/for_perl6 Folders 'nqp' and 'MoarVM' with corresponding git repos should be in for_perl6 folder --makefile-timing Enable timing of individual makefile commands Configure.pl also reads options from 'config.default' in the current directory. END return; } # Local Variables: # mode: cperl # cperl-indent-level: 4 # fill-column: 100 # End: # vim: expandtab shiftwidth=4: rakudo-2015.11/INSTALL.txt000644 000765 000024 00000016256 12573566321 017014 0ustar00williamcoledastaff000000 000000 Build requirements (Installing from source) For building Rakudo you need at least a C compiler, a "make" utility, and Perl 5.8 or newer. To automatically obtain and build MoarVM as well as NQP, you may also need a git client, which is also needed for fetching the test suite. Building rakudo can take up to 1G of memory when compiling for the MoarVM runtime. The requirements are higher for the JVM backend. (Perl is installed by default already). To enable parallel testing you also need the CPAN module Test::Harness in version 3.16 or newer; you can control the number of parallel jobs with the "TEST_JOBS" environment variable. Building and invoking Rakudo If you're wanting the bleeding-edge version of the Rakudo Perl 6 compiler, we recommend downloading Rakudo directly from Github and building it from there. $ git clone git://github.com/rakudo/rakudo.git If you don't have git installed, you can get a tarball of Rakudo from . Then unpack the tarball. If you already have cloned Rakudo from github, you can get (pull) the most recent version from github like this: $ cd rakudo $ git pull Once you have an up-to-date copy of Rakudo, build it as follows: $ perl Configure.pl --gen-moar --gen-nqp --backends=moar # Moar only or: $ perl Configure.pl --gen-nqp --backends=jvm # needs JDK 1.7 installed then: $ make This will create a "perl6" or "perl6.exe" executable in the current (rakudo) directory. Additionally, for each selected backend, there will be a perl6-* binary. Note that if you have multiple (Perl 5) "perl"s in your path, you may need to use a fully qualified path to the appropriate executable (or update your PATH environment variable). Programs can then be run from the build directory using a command like: $ ./perl6 hello.pl Simply running "perl6" will drop you into a REPL (read-eval-print-loop) that you can use for exploratory programming: $ ./perl6 If you would like readline-like features, such as command history, line editing, and tab completion for builtins, you should install the Linenoise module via panda: $ panda install Linenoise Important: To run Rakudo from outside the build directory, you must run $ make install This will install the "perl6" (or "perl6.exe" binary on windows) into the "install/bin" directory locally, no additional root privileges necessary. If you want to have perl6, nqp, and moar installed into a different directory, you may supply --prefix= to Configure.pl. The "--gen-moar" above option tells Configure.pl to automatically download and build the most appropriate version of NQP and MoarVM into local "nqp/" and "moar/" subdirectories, install NQP and MoarVM into the "install/" subdirectory, and use them for building Rakudo. It's okay to use the "--gen-moar" option on later invocations of Configure.pl; the configure system will re-build NQP and/or MoarVM only if a newer version is needed for whatever version of Rakudo you're working with. If you already have MoarVM installed, you can use "--with-moar=/path/to/bin/moar" to use it instead of building a new one. This installed MoarVM must include its development environment. Similarly, if you already have NQP installed, you can specify "--with-nqp=/path/to/bin/nqp" to use it. (Note that this must be NQP, not the NQP-rx that comes with MoarVM.) The versions of any already installed NQP or MoarVM binaries must satify a minimum specified by the Rakudo being built -- Configure.pl and "make" will verify this for you. Released versions of Rakudo generally build against the latest release of MoarVM; checkouts of Rakudo's HEAD revision from Github often require a version of MoarVM that is newer than the most recent MoarVM monthly release. Once built, Rakudo's "make install" target will install Rakudo and its libraries into the directories specified by the MoarVM installation used to create it or whatever you specified with the --prefix flag. Until this step is performed, the "perl6" executable created by "make" above can only be reliably run from the root of Rakudo's build directory. After "make install" is performed, the installed executable can be run from any directory (as long as the MoarVM installation that were used to create it remain intact). If the Rakudo compiler is invoked without an explicit script to run, it enters a small interactive mode that allows Perl 6 statements to be executed from an interactive prompt. See the manual page ("docs/running.pod") for more about command-line options. Build/install problems Occasionally, there may be problems when building/installing Rakudo. Make sure you have a backup of any custom changes you have done to the source tree before performing the following steps: Try to remove the "install/" subdirectory: $ cd rakudo $ rm -r install $ git pull $ perl Configure.pl --gen-moar --gen-nqp --backends=moar # for instance $ make Or, in case you are really stuck, start with a fresh source tree: $ rm -r rakudo $ git clone git://github.com/rakudo/rakudo.git Running the test suite Entering "make test" will run a small test suite that comes bundled with Rakudo. This is a simple suite of tests, designed to make sure that the Rakudo compiler is basically working and that it's capable of running a simple test harness. Running "make spectest" will import the official Perl 6 test suite from the "roast" repository and run all of these tests that are currently known to pass. You can compare your own results to the results of the daily runs in . At present we do not have any plans to directly store the official test suite as part of the Rakudo repository, but will continue to fetch it from the roast repository. Releases of Rakudo get a snapshot of the roast repository as of the time of the release. You can also use "make" to run an individual test from the command line: $ make t/spec/S29-str/ucfirst.t t/spec/S29-str/ucfirst.rakudo .. 1..4 ok 1 - simple ok 2 - empty string ok 3 - # SKIP unicode ok 4 - # SKIP unicode # FUDGED! ok All tests successful. Files=1, Tests=4, 1 wallclock secs ( 0.02 usr 0.00 sys + 0.57 cusr 0.06 csys = 0.65 CPU) Result: PASS If you want to run the tests in parallel, you need to install a fairly recent version of the Perl 5 module Test::Harness (3.16 works for sure). Spectest smolder requirements (Windows) You need recent version of either Strawberry Perl or ActiveState Perl. If you are working with ActiveState Perl you need the Mingw gcc compiler. You need msys git installed and you need "\Program Files\Git\cmd" on your execution path and NOT "\Program Files\Git\bin". You need a win32 curl program. rakudo-2015.11/LICENSE000644 000765 000024 00000021306 12573545400 016135 0ustar00williamcoledastaff000000 000000 The Artistic License 2.0 Copyright (c) 2000-2015, The Perl Foundation. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble This license establishes the terms under which a given free software Package may be copied, modified, distributed, and/or redistributed. The intent is that the Copyright Holder maintains some artistic control over the development of that Package while still keeping the Package available as open source and free software. You are always permitted to make arrangements wholly outside of this license directly with the Copyright Holder of a given Package. If the terms of this license do not permit the full use that you propose to make of the Package, you should contact the Copyright Holder and seek a different licensing arrangement. Definitions "Copyright Holder" means the individual(s) or organization(s) named in the copyright notice for the entire Package. "Contributor" means any party that has contributed code or other material to the Package, in accordance with the Copyright Holder's procedures. "You" and "your" means any person who would like to copy, distribute, or modify the Package. "Package" means the collection of files distributed by the Copyright Holder, and derivatives of that collection and/or of those files. A given Package may consist of either the Standard Version, or a Modified Version. "Distribute" means providing a copy of the Package or making it accessible to anyone else, or in the case of a company or organization, to others outside of your company or organization. "Distributor Fee" means any fee that you charge for Distributing this Package or providing support for this Package to another party. It does not mean licensing fees. "Standard Version" refers to the Package if it has not been modified, or has been modified only in ways explicitly requested by the Copyright Holder. "Modified Version" means the Package, if it has been changed, and such changes were not explicitly requested by the Copyright Holder. "Original License" means this Artistic License as Distributed with the Standard Version of the Package, in its current version or as it may be modified by The Perl Foundation in the future. "Source" form means the source code, documentation source, and configuration files for the Package. "Compiled" form means the compiled bytecode, object code, binary, or any other form resulting from mechanical transformation or translation of the Source form. Permission for Use and Modification Without Distribution (1) You are permitted to use the Standard Version and create and use Modified Versions for any purpose without restriction, provided that you do not Distribute the Modified Version. Permissions for Redistribution of the Standard Version (2) You may Distribute verbatim copies of the Source form of the Standard Version of this Package in any medium without restriction, either gratis or for a Distributor Fee, provided that you duplicate all of the original copyright notices and associated disclaimers. At your discretion, such verbatim copies may or may not include a Compiled form of the Package. (3) You may apply any bug fixes, portability changes, and other modifications made available from the Copyright Holder. The resulting Package will still be considered the Standard Version, and as such will be subject to the Original License. Distribution of Modified Versions of the Package as Source (4) You may Distribute your Modified Version as Source (either gratis or for a Distributor Fee, and with or without a Compiled form of the Modified Version) provided that you clearly document how it differs from the Standard Version, including, but not limited to, documenting any non-standard features, executables, or modules, and provided that you do at least ONE of the following: (a) make the Modified Version available to the Copyright Holder of the Standard Version, under the Original License, so that the Copyright Holder may include your modifications in the Standard Version. (b) ensure that installation of your Modified Version does not prevent the user installing or running the Standard Version. In addition, the Modified Version must bear a name that is different from the name of the Standard Version. (c) allow anyone who receives a copy of the Modified Version to make the Source form of the Modified Version available to others under (i) the Original License or (ii) a license that permits the licensee to freely copy, modify and redistribute the Modified Version using the same licensing terms that apply to the copy that the licensee received, and requires that the Source form of the Modified Version, and of any works derived from it, be made freely available in that license fees are prohibited but Distributor Fees are allowed. Distribution of Compiled Forms of the Standard Version or Modified Versions without the Source (5) You may Distribute Compiled forms of the Standard Version without the Source, provided that you include complete instructions on how to get the Source of the Standard Version. Such instructions must be valid at the time of your distribution. If these instructions, at any time while you are carrying out such distribution, become invalid, you must provide new instructions on demand or cease further distribution. If you provide valid instructions or cease distribution within thirty days after you become aware that the instructions are invalid, then you do not forfeit any of your rights under this license. (6) You may Distribute a Modified Version in Compiled form without the Source, provided that you comply with Section 4 with respect to the Source of the Modified Version. Aggregating or Linking the Package (7) You may aggregate the Package (either the Standard Version or Modified Version) with other packages and Distribute the resulting aggregation provided that you do not charge a licensing fee for the Package. Distributor Fees are permitted, and licensing fees for other components in the aggregation are permitted. The terms of this license apply to the use and Distribution of the Standard or Modified Versions as included in the aggregation. (8) You are permitted to link Modified and Standard Versions with other works, to embed the Package in a larger work of your own, or to build stand-alone binary or bytecode versions of applications that include the Package, and Distribute the result without restriction, provided the result does not expose a direct interface to the Package. Items That are Not Considered Part of a Modified Version (9) Works (including, but not limited to, modules and scripts) that merely extend or make use of the Package, do not, by themselves, cause the Package to be a Modified Version. In addition, such works are not considered parts of the Package itself, and are not subject to the terms of this license. General Provisions (10) Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license. (11) If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license. (12) This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder. (13) This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed. (14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. rakudo-2015.11/MANIFEST000644 000765 000024 00000151330 12623512070 016253 0ustar00williamcoledastaff000000 000000 CREDITS Configure.pl INSTALL.txt LICENSE MANIFEST README.md VERSION blib/Perl6/.gitignore docs/ChangeLog docs/ROADMAP docs/S11-Modules-proposal.pod docs/announce/2009-02 docs/announce/2009-03 docs/announce/2009-04 docs/announce/2009-05 docs/announce/2009-06 docs/announce/2009-07 docs/announce/2009-08 docs/announce/2009-09 docs/announce/2009-10 docs/announce/2009-11 docs/announce/2009-12 docs/announce/2010-01 docs/announce/2010.02 docs/announce/2010.03 docs/announce/2010.04 docs/announce/2010.05 docs/announce/2010.06 docs/announce/2010.07 docs/announce/2010.08 docs/announce/2010.09 docs/announce/2010.10 docs/announce/2010.11 docs/announce/2010.12 docs/announce/2011.01 docs/announce/2011.02 docs/announce/2011.03 docs/announce/2011.04 docs/announce/2011.05 docs/announce/2011.06 docs/announce/2011.07 docs/announce/2011.09 docs/announce/2011.10 docs/announce/2011.11 docs/announce/2011.12 docs/announce/2012.01 docs/announce/2012.02 docs/announce/2012.03 docs/announce/2012.04 docs/announce/2012.04.1 docs/announce/2012.05 docs/announce/2012.06 docs/announce/2012.07 docs/announce/2012.08 docs/announce/2012.09 docs/announce/2012.09.1 docs/announce/2012.10 docs/announce/2012.11 docs/announce/2012.12 docs/announce/2013.01 docs/announce/2013.02 docs/announce/2013.03.md docs/announce/2013.04.md docs/announce/2013.05.md docs/announce/2013.06.md docs/announce/2013.07.md docs/announce/2013.08.md docs/announce/2013.09.md docs/announce/2013.10.md docs/announce/2013.11.md docs/announce/2013.12.md docs/announce/2014.01.md docs/announce/2014.02.md docs/announce/2014.03.md docs/announce/2014.04.md docs/announce/2014.05.md docs/announce/2014.06.md docs/announce/2014.07.md docs/announce/2014.08.md docs/announce/2014.09.md docs/announce/2014.10.md docs/announce/2014.11.md docs/announce/2014.12.md docs/announce/2015.01.md docs/announce/2015.02.md docs/announce/2015.03.md docs/announce/2015.04.md docs/announce/2015.05.md docs/announce/2015.06.md docs/announce/2015.07.md docs/announce/2015.08.md docs/announce/2015.09.md docs/announce/2015.10.md docs/announce/2015.11.md docs/architecture.html docs/architecture.svg docs/compiler_overview.pod docs/deprecations docs/glossary.pod docs/guide_to_setting.pod docs/metamodel.pod docs/metaobject-api.pod docs/obtaining-a-commit-bit.pod docs/release_guide.pod docs/running.pod docs/spectest-progress.csv docs/val.pod6 dynext/IGNORE gen/jvm/.gitignore gen/moar/.gitignore lib/NativeCall.pm lib/NativeCall/Compiler/GNU.pm lib/NativeCall/Compiler/MSVC.pm lib/NativeCall/Types.pm lib/Pod/To/Text.pm lib/Test.pm lib/lib.pm6 lib/newline.pm6 src/Perl6/Actions.nqp src/Perl6/Compiler.nqp src/Perl6/Grammar.nqp src/Perl6/Metamodel/Archetypes.nqp src/Perl6/Metamodel/ArrayType.nqp src/Perl6/Metamodel/AttributeContainer.nqp src/Perl6/Metamodel/BOOTSTRAP.nqp src/Perl6/Metamodel/BUILDPLAN.nqp src/Perl6/Metamodel/BaseType.nqp src/Perl6/Metamodel/BoolificationProtocol.nqp src/Perl6/Metamodel/C3MRO.nqp src/Perl6/Metamodel/ClassHOW.nqp src/Perl6/Metamodel/CoercionHOW.nqp src/Perl6/Metamodel/ConcreteRoleHOW.nqp src/Perl6/Metamodel/Configuration.nqp src/Perl6/Metamodel/ContainerDescriptor.nqp src/Perl6/Metamodel/CurriedRoleHOW.nqp src/Perl6/Metamodel/DefaultParent.nqp src/Perl6/Metamodel/DefiniteHOW.nqp src/Perl6/Metamodel/Dispatchers.nqp src/Perl6/Metamodel/Documenting.nqp src/Perl6/Metamodel/EXPORTHOW.nqp src/Perl6/Metamodel/EnumHOW.nqp src/Perl6/Metamodel/Finalization.nqp src/Perl6/Metamodel/GenericHOW.nqp src/Perl6/Metamodel/GrammarHOW.nqp src/Perl6/Metamodel/InvocationProtocol.nqp src/Perl6/Metamodel/MROBasedMethodDispatch.nqp src/Perl6/Metamodel/MROBasedTypeChecking.nqp src/Perl6/Metamodel/MetaMethodContainer.nqp src/Perl6/Metamodel/MethodContainer.nqp src/Perl6/Metamodel/MethodDelegation.nqp src/Perl6/Metamodel/Mixins.nqp src/Perl6/Metamodel/ModuleHOW.nqp src/Perl6/Metamodel/MultiMethodContainer.nqp src/Perl6/Metamodel/MultipleInheritance.nqp src/Perl6/Metamodel/Naming.nqp src/Perl6/Metamodel/NativeHOW.nqp src/Perl6/Metamodel/NativeRefHOW.nqp src/Perl6/Metamodel/PackageHOW.nqp src/Perl6/Metamodel/ParametricRoleGroupHOW.nqp src/Perl6/Metamodel/ParametricRoleHOW.nqp src/Perl6/Metamodel/PrivateMethodContainer.nqp src/Perl6/Metamodel/REPRComposeProtocol.nqp src/Perl6/Metamodel/RoleContainer.nqp src/Perl6/Metamodel/RolePunning.nqp src/Perl6/Metamodel/RoleToClassApplier.nqp src/Perl6/Metamodel/RoleToRoleApplier.nqp src/Perl6/Metamodel/Stashing.nqp src/Perl6/Metamodel/SubsetHOW.nqp src/Perl6/Metamodel/Trusting.nqp src/Perl6/Metamodel/TypePretense.nqp src/Perl6/Metamodel/Versioning.nqp src/Perl6/ModuleLoader.nqp src/Perl6/Optimizer.nqp src/Perl6/Pod.nqp src/Perl6/World.nqp src/RESTRICTED.setting src/core/AST.pm src/core/Any-iterable-methods.pm src/core/Any.pm src/core/Argfiles.pm src/core/Array.pm src/core/Associative.pm src/core/Attribute.pm src/core/Backtrace.pm src/core/Bag.pm src/core/BagHash.pm src/core/Baggy.pm src/core/Block.pm src/core/Bool.pm src/core/Buf.pm src/core/CallFrame.pm src/core/Callable.pm src/core/Cancellation.pm src/core/Capture.pm src/core/Channel.pm src/core/Code.pm src/core/CompUnit.pm src/core/CompUnitRepo.pm src/core/CompUnitRepo/Local/File.pm src/core/CompUnitRepo/Local/Installation.pm src/core/CompUnitRepo/Locally.pm src/core/Compiler.pm src/core/Complex.pm src/core/Cool.pm src/core/CurrentThreadScheduler.pm src/core/Cursor.pm src/core/Deprecations.pm src/core/Distribution.pm src/core/Distro.pm src/core/Duration.pm src/core/EXPORTHOW.pm src/core/Enumeration.pm src/core/Env.pm src/core/Exception.pm src/core/Failure.pm src/core/ForeignCode.pm src/core/Grammar.pm src/core/Hash.pm src/core/HyperConfiguration.pm src/core/HyperIterable.pm src/core/HyperIterator.pm src/core/HyperSeq.pm src/core/HyperWorkBuffer.pm src/core/IO.pm src/core/IO/ArgFiles.pm src/core/IO/Dir.pm src/core/IO/Dup.pm src/core/IO/File.pm src/core/IO/Handle.pm src/core/IO/Huh.pm src/core/IO/Local.pm src/core/IO/Notification.pm src/core/IO/Path.pm src/core/IO/Pathy.pm src/core/IO/Pipe.pm src/core/IO/Socket.pm src/core/IO/Socket/Async.pm src/core/IO/Socket/INET.pm src/core/IO/Spec.pm src/core/IO/Spec/Cygwin.pm src/core/IO/Spec/QNX.pm src/core/IO/Spec/Unix.pm src/core/IO/Spec/Win32.pm src/core/IO/Special.pm src/core/Inc.pm src/core/Instant.pm src/core/Int.pm src/core/Iterable.pm src/core/IterationBuffer.pm src/core/Iterator.pm src/core/JSON/Pretty.pm src/core/JVM/IOAsyncFile.pm src/core/JVM/KeyReducer.pm src/core/Junction.pm src/core/Kernel.pm src/core/Label.pm src/core/List.pm src/core/Lock.pm src/core/Macro.pm src/core/Main.pm src/core/Map.pm src/core/Match.pm src/core/Metamodel/Primitives.pm src/core/Method.pm src/core/Mix.pm src/core/MixHash.pm src/core/Mixy.pm src/core/Mu.pm src/core/Nil.pm src/core/Num.pm src/core/Numeric.pm src/core/OS.pm src/core/ObjAt.pm src/core/Order.pm src/core/PIO.pm src/core/Pair.pm src/core/Parameter.pm src/core/Perl.pm src/core/Pod.pm src/core/Positional.pm src/core/Proc.pm src/core/Proc/Async.pm src/core/Process.pm src/core/Promise.pm src/core/PseudoStash.pm src/core/QuantHash.pm src/core/Rakudo/Internals.pm src/core/Range.pm src/core/Rat.pm src/core/Rational.pm src/core/Real.pm src/core/Regex.pm src/core/Routine.pm src/core/SLICE.pm src/core/Scalar.pm src/core/Scheduler.pm src/core/Semaphore.pm src/core/Seq.pm src/core/Set.pm src/core/SetHash.pm src/core/Setty.pm src/core/Signature.pm src/core/Slang.pm src/core/Slip.pm src/core/SlippyIterator.pm src/core/Stash.pm src/core/Str.pm src/core/StrDistance.pm src/core/Stringy.pm src/core/Sub.pm src/core/Submethod.pm src/core/Supply.pm src/core/SupplyOperations.pm src/core/Systemic.pm src/core/Temporal.pm src/core/Thread.pm src/core/ThreadPoolScheduler.pm src/core/UInt64.pm src/core/Uni.pm src/core/VM.pm src/core/Variable.pm src/core/Version.pm src/core/Whatever.pm src/core/WhateverCode.pm src/core/allomorphs.pm src/core/array_slice.pm src/core/asyncops.pm src/core/control.pm src/core/core_epilogue.pm src/core/core_prologue.pm src/core/hash_slice.pm src/core/io_operators.pm src/core/metaops.pm src/core/native_array.pm src/core/natives.pm src/core/operators.pm src/core/precedence.pm src/core/set_operators.pm src/core/signals.pm src/core/stubs.pm src/core/tai-utc.pm src/core/traits.pm src/main.nqp src/perl6-debug.nqp src/vm/jvm/ModuleLoaderVMConfig.nqp src/vm/jvm/Perl6/JavaModuleLoader.nqp src/vm/jvm/Perl6/Metamodel/JavaHOW.nqp src/vm/jvm/Perl6/Ops.nqp src/vm/jvm/runtime/org/perl6/rakudo/Binder.java src/vm/jvm/runtime/org/perl6/rakudo/RakOps.java src/vm/jvm/runtime/org/perl6/rakudo/RakudoContainerConfigurer.java src/vm/jvm/runtime/org/perl6/rakudo/RakudoContainerSpec.java src/vm/jvm/runtime/org/perl6/rakudo/RakudoEvalServer.java src/vm/jvm/runtime/org/perl6/rakudo/RakudoJavaInterop.java src/vm/moar/ModuleLoaderVMConfig.nqp src/vm/moar/Perl6/Ops.nqp src/vm/moar/ops/container.c src/vm/moar/ops/container.h src/vm/moar/ops/perl6_ops.c t/01-sanity/01-literals.t t/01-sanity/02-op-math.t t/01-sanity/03-op-logic.t t/01-sanity/04-op-cmp.t t/01-sanity/05-var.t t/01-sanity/06-op-inplace.t t/01-sanity/07-op-string.t t/01-sanity/08-var-array.t t/01-sanity/09-end-blocks.t t/01-sanity/10-regex.t t/01-sanity/11-tap.t t/01-sanity/12-counter.t t/01-sanity/13-equal.t t/01-sanity/14-if.t t/01-sanity/15-sub.t t/01-sanity/16-eqv.t t/01-sanity/17-isa.t t/01-sanity/18-simple-multisubs.t t/01-sanity/19-say.t t/01-sanity/20-defined.t t/01-sanity/21-try.t t/01-sanity/52-parse-include-spec.t t/01-sanity/53-transpose.t t/01-sanity/54-use-lib.t t/01-sanity/55-use-trace.t t/01-sanity/99-test-basic.t t/02-rakudo/01-is_approx.t t/02-rakudo/02-new-is_approx.t t/02-rakudo/dump.t t/02-rakudo/repl.t t/03-jvm/01-interop.t t/04-nativecall/01-argless.c t/04-nativecall/01-argless.t t/04-nativecall/02-simple-args.c t/04-nativecall/02-simple-args.t t/04-nativecall/03-simple-returns.c t/04-nativecall/03-simple-returns.t t/04-nativecall/04-pointers.c t/04-nativecall/04-pointers.t t/04-nativecall/05-arrays.c t/04-nativecall/05-arrays.t t/04-nativecall/06-struct.c t/04-nativecall/06-struct.t t/04-nativecall/07-writebarrier.c t/04-nativecall/07-writebarrier.t t/04-nativecall/08-callbacks.c t/04-nativecall/08-callbacks.t t/04-nativecall/09-nativecast.c t/04-nativecall/09-nativecast.t t/04-nativecall/10-cglobals.c t/04-nativecall/10-cglobals.t t/04-nativecall/11-cpp.cpp t/04-nativecall/11-cpp.t t/04-nativecall/12-sizeof.c t/04-nativecall/12-sizeof.t t/04-nativecall/13-cpp-mangling.cpp t/04-nativecall/13-cpp-mangling.t t/04-nativecall/13-union.c t/04-nativecall/13-union.t t/04-nativecall/14-rw-attrs.c t/04-nativecall/14-rw-attrs.t t/04-nativecall/15-rw-args.c t/04-nativecall/15-rw-args.t t/04-nativecall/16-rt125408.t t/04-nativecall/16-rt125729.t t/04-nativecall/CompileTestLib.pm t/fudgeandrun t/harness t/spec/LICENSE t/spec/README t/spec/S01-perl-5-integration/README t/spec/S01-perl-5-integration/array.t t/spec/S01-perl-5-integration/basic.t t/spec/S01-perl-5-integration/class.t t/spec/S01-perl-5-integration/context.t t/spec/S01-perl-5-integration/eval_lex.t t/spec/S01-perl-5-integration/exception_handling.t t/spec/S01-perl-5-integration/hash.t t/spec/S01-perl-5-integration/import.t t/spec/S01-perl-5-integration/method.t t/spec/S01-perl-5-integration/modify_inside_p5.t t/spec/S01-perl-5-integration/modify_inside_p5_p6.t t/spec/S01-perl-5-integration/return.t t/spec/S01-perl-5-integration/roundtrip.t t/spec/S01-perl-5-integration/strings.t t/spec/S01-perl-5-integration/subs.t t/spec/S02-lexical-conventions/begin_end_pod.t t/spec/S02-lexical-conventions/bom.t t/spec/S02-lexical-conventions/comments.t t/spec/S02-lexical-conventions/end-pod.t t/spec/S02-lexical-conventions/minimal-whitespace.t t/spec/S02-lexical-conventions/one-pass-parsing.t t/spec/S02-lexical-conventions/pod-in-multi-line-exprs.t t/spec/S02-lexical-conventions/sub-block-parsing.t t/spec/S02-lexical-conventions/unicode-whitespace.t t/spec/S02-lexical-conventions/unicode.t t/spec/S02-lexical-conventions/unspace.t t/spec/S02-lists/indexing.t t/spec/S02-lists/tree.t t/spec/S02-literals/adverbs.t t/spec/S02-literals/allomorphic.t t/spec/S02-literals/array-interpolation.t t/spec/S02-literals/autoref.t t/spec/S02-literals/char-by-name.t t/spec/S02-literals/char-by-number.t t/spec/S02-literals/fmt-interpolation.t t/spec/S02-literals/hash-interpolation.t t/spec/S02-literals/heredocs.t t/spec/S02-literals/hex_chars.t t/spec/S02-literals/listquote-whitespace.t t/spec/S02-literals/listquote.t t/spec/S02-literals/misc-interpolation.t t/spec/S02-literals/numeric.t t/spec/S02-literals/pair-boolean.t t/spec/S02-literals/pairs.t t/spec/S02-literals/pod.t t/spec/S02-literals/quoting-unicode.t t/spec/S02-literals/quoting.t t/spec/S02-literals/radix.t t/spec/S02-literals/string-interpolation.t t/spec/S02-literals/sub-calls.t t/spec/S02-literals/subscript.t t/spec/S02-literals/types.t t/spec/S02-literals/underscores.t t/spec/S02-literals/version.t t/spec/S02-magicals/78258.t t/spec/S02-magicals/DISTRO.t t/spec/S02-magicals/KERNEL.t t/spec/S02-magicals/PERL.t t/spec/S02-magicals/UsedEnv.pm6 t/spec/S02-magicals/VM.t t/spec/S02-magicals/args.t t/spec/S02-magicals/block.t t/spec/S02-magicals/dollar-underscore.t t/spec/S02-magicals/dollar_bang.t t/spec/S02-magicals/env.t t/spec/S02-magicals/file_line.t t/spec/S02-magicals/pid.t t/spec/S02-magicals/progname.t t/spec/S02-magicals/sub.t t/spec/S02-magicals/subname.t t/spec/S02-names-vars/contextual.t t/spec/S02-names-vars/fmt.t t/spec/S02-names-vars/list_array_perl.t t/spec/S02-names-vars/names.t t/spec/S02-names-vars/perl.t t/spec/S02-names-vars/signature.t t/spec/S02-names-vars/variables-and-packages.t t/spec/S02-names-vars/varnames.t t/spec/S02-names/bare-sigil.t t/spec/S02-names/caller.t t/spec/S02-names/identifier.t t/spec/S02-names/indirect.t t/spec/S02-names/is_cached.t t/spec/S02-names/is_default.t t/spec/S02-names/is_dynamic.t t/spec/S02-names/name.t t/spec/S02-names/our.t t/spec/S02-names/pseudo.t t/spec/S02-names/strict.t t/spec/S02-names/symbolic-deref.t t/spec/S02-one-pass-parsing/less-than.t t/spec/S02-packages/package-lookup.t t/spec/S02-types/WHICH.t t/spec/S02-types/anon_block.t t/spec/S02-types/array-shapes.t t/spec/S02-types/array.t t/spec/S02-types/array_extending.t t/spec/S02-types/array_ref.t t/spec/S02-types/assigning-refs.t t/spec/S02-types/autovivification.t t/spec/S02-types/bag.t t/spec/S02-types/baghash.t t/spec/S02-types/bool.t t/spec/S02-types/built-in.t t/spec/S02-types/capture.t t/spec/S02-types/catch_type_cast_mismatch.t t/spec/S02-types/compact.t t/spec/S02-types/declare.t t/spec/S02-types/fatrat.t t/spec/S02-types/flattening.t t/spec/S02-types/hash.t t/spec/S02-types/hash_ref.t t/spec/S02-types/infinity.t t/spec/S02-types/instants-and-durations.t t/spec/S02-types/int-uint.t t/spec/S02-types/is-type.t t/spec/S02-types/isDEPRECATED.t t/spec/S02-types/keyhash.t t/spec/S02-types/lazy-lists.t t/spec/S02-types/list.t t/spec/S02-types/lists.t t/spec/S02-types/mix.t t/spec/S02-types/mixed_multi_dimensional.t t/spec/S02-types/mixhash.t t/spec/S02-types/multi_dimensional_array.t t/spec/S02-types/nan.t t/spec/S02-types/native.t t/spec/S02-types/nested_arrays.t t/spec/S02-types/nested_pairs.t t/spec/S02-types/nil.t t/spec/S02-types/num.t t/spec/S02-types/pair.t t/spec/S02-types/parsing-bool.t t/spec/S02-types/range.t t/spec/S02-types/set.t t/spec/S02-types/sethash.t t/spec/S02-types/sigils-and-types.t t/spec/S02-types/stash.t t/spec/S02-types/subscripts_and_context.t t/spec/S02-types/subset.t t/spec/S02-types/type.t t/spec/S02-types/undefined-types.t t/spec/S02-types/unicode.t t/spec/S02-types/version.t t/spec/S02-types/whatever.t t/spec/S03-binding/arrays.t t/spec/S03-binding/attributes.t t/spec/S03-binding/closure.t t/spec/S03-binding/hashes.t t/spec/S03-binding/nested.t t/spec/S03-binding/ro.t t/spec/S03-binding/scalars.t t/spec/S03-binding/subs.t t/spec/S03-feeds/basic.t t/spec/S03-junctions/associative.t t/spec/S03-junctions/autothreading.t t/spec/S03-junctions/boolean-context.t t/spec/S03-junctions/misc.t t/spec/S03-metaops/cross.t t/spec/S03-metaops/eager-hyper.t t/spec/S03-metaops/hyper.t t/spec/S03-metaops/not.t t/spec/S03-metaops/reduce.t t/spec/S03-metaops/reverse.t t/spec/S03-metaops/zip.t t/spec/S03-operators/adverbial-modifiers.t t/spec/S03-operators/also.t t/spec/S03-operators/andthen.t t/spec/S03-operators/arith.t t/spec/S03-operators/assign-is-not-binding.t t/spec/S03-operators/assign.t t/spec/S03-operators/autoincrement-range.t t/spec/S03-operators/autoincrement.t t/spec/S03-operators/autovivification.t t/spec/S03-operators/bag.t t/spec/S03-operators/basic-types.t t/spec/S03-operators/bit.t t/spec/S03-operators/boolean-bitwise.t t/spec/S03-operators/brainos.t t/spec/S03-operators/buf.t t/spec/S03-operators/chained-declarators.t t/spec/S03-operators/cmp.t t/spec/S03-operators/comparison-simple.t t/spec/S03-operators/comparison.t t/spec/S03-operators/composition.t t/spec/S03-operators/context-forcers.t t/spec/S03-operators/context.t t/spec/S03-operators/custom.t t/spec/S03-operators/div.t t/spec/S03-operators/equality.t t/spec/S03-operators/eqv.t t/spec/S03-operators/flip-flop.t t/spec/S03-operators/gcd.t t/spec/S03-operators/identity.t t/spec/S03-operators/increment.t t/spec/S03-operators/infixed-function.t t/spec/S03-operators/inplace.t t/spec/S03-operators/is-divisible-by.t t/spec/S03-operators/lcm.t t/spec/S03-operators/list-quote-junction.t t/spec/S03-operators/minmax.t t/spec/S03-operators/misc.t t/spec/S03-operators/mix.t t/spec/S03-operators/names.t t/spec/S03-operators/nesting.t t/spec/S03-operators/not.t t/spec/S03-operators/numeric-shift.t t/spec/S03-operators/orelse.t t/spec/S03-operators/overflow.t t/spec/S03-operators/precedence.t t/spec/S03-operators/range-basic.t t/spec/S03-operators/range-int.t t/spec/S03-operators/range.t t/spec/S03-operators/reduce-le1arg.t t/spec/S03-operators/relational.t t/spec/S03-operators/repeat.t t/spec/S03-operators/scalar-assign.t t/spec/S03-operators/set.t t/spec/S03-operators/short-circuit.t t/spec/S03-operators/shortcuts.t t/spec/S03-operators/so.t t/spec/S03-operators/spaceship-and-containers.t t/spec/S03-operators/spaceship.t t/spec/S03-operators/subscript-adverbs.t t/spec/S03-operators/subscript-vs-lt.t t/spec/S03-operators/ternary.t t/spec/S03-operators/value_equivalence.t t/spec/S03-sequence/arity-2-or-more.t t/spec/S03-sequence/arity0.t t/spec/S03-sequence/basic.t t/spec/S03-sequence/limit-arity-2-or-more.t t/spec/S03-sequence/misc.t t/spec/S03-sequence/nonnumeric.t t/spec/S03-smartmatch/any-any.t t/spec/S03-smartmatch/any-bool.t t/spec/S03-smartmatch/any-callable.t t/spec/S03-smartmatch/any-complex.t t/spec/S03-smartmatch/any-hash-pair.t t/spec/S03-smartmatch/any-method.t t/spec/S03-smartmatch/any-num.t t/spec/S03-smartmatch/any-pair.t t/spec/S03-smartmatch/any-str.t t/spec/S03-smartmatch/any-sub.t t/spec/S03-smartmatch/any-type.t t/spec/S03-smartmatch/array-array.t t/spec/S03-smartmatch/array-hash.t t/spec/S03-smartmatch/capture-signature.t t/spec/S03-smartmatch/disorganized.t t/spec/S03-smartmatch/hash-hash.t t/spec/S03-smartmatch/range-range.t t/spec/S03-smartmatch/regex-hash.t t/spec/S03-smartmatch/scalar-hash.t t/spec/S03-smartmatch/signature-signature.t t/spec/S04-blocks-and-statements/let.t t/spec/S04-blocks-and-statements/pointy-rw.t t/spec/S04-blocks-and-statements/pointy.t t/spec/S04-blocks-and-statements/temp.t t/spec/S04-declarations/constant.t t/spec/S04-declarations/implicit-parameter.t t/spec/S04-declarations/multiple.t t/spec/S04-declarations/my.t t/spec/S04-declarations/our.t t/spec/S04-declarations/smiley.t t/spec/S04-declarations/state.t t/spec/S04-declarations/will.t t/spec/S04-exception-handlers/catch.t t/spec/S04-exception-handlers/control.t t/spec/S04-exception-handlers/top-level.t t/spec/S04-exceptions/control_across_runloop.t t/spec/S04-exceptions/fail.t t/spec/S04-exceptions/pending.t t/spec/S04-phasers/ascending-order.t t/spec/S04-phasers/begin.t t/spec/S04-phasers/check.t t/spec/S04-phasers/descending-order.t t/spec/S04-phasers/end.t t/spec/S04-phasers/enter-leave.t t/spec/S04-phasers/eval-in-begin.t t/spec/S04-phasers/exit-in-begin.t t/spec/S04-phasers/exit-in-check.t t/spec/S04-phasers/first.t t/spec/S04-phasers/in-eval.t t/spec/S04-phasers/in-loop.t t/spec/S04-phasers/init.t t/spec/S04-phasers/interpolate.t t/spec/S04-phasers/keep-undo.t t/spec/S04-phasers/multiple.t t/spec/S04-phasers/next.t t/spec/S04-phasers/pre-post.t t/spec/S04-phasers/rvalue.t t/spec/S04-statement-modifiers/for.t t/spec/S04-statement-modifiers/given.t t/spec/S04-statement-modifiers/if.t t/spec/S04-statement-modifiers/unless.t t/spec/S04-statement-modifiers/until.t t/spec/S04-statement-modifiers/values_in_bool_context.t t/spec/S04-statement-modifiers/while.t t/spec/S04-statement-modifiers/with.t t/spec/S04-statement-modifiers/without.t t/spec/S04-statement-parsing/hash.t t/spec/S04-statements/do.t t/spec/S04-statements/for-scope.t t/spec/S04-statements/for.t t/spec/S04-statements/for_with_only_one_item.t t/spec/S04-statements/gather.t t/spec/S04-statements/given.t t/spec/S04-statements/goto.t t/spec/S04-statements/if.t t/spec/S04-statements/label.t t/spec/S04-statements/last.t t/spec/S04-statements/lazy.t t/spec/S04-statements/leave.t t/spec/S04-statements/loop.t t/spec/S04-statements/map-and-sort-in-for.t t/spec/S04-statements/next.t t/spec/S04-statements/no-implicit-block.t t/spec/S04-statements/once.t t/spec/S04-statements/quietly.t t/spec/S04-statements/redo.t t/spec/S04-statements/repeat.t t/spec/S04-statements/return.t t/spec/S04-statements/sink.t t/spec/S04-statements/terminator.t t/spec/S04-statements/try.t t/spec/S04-statements/unless.t t/spec/S04-statements/until.t t/spec/S04-statements/when.t t/spec/S04-statements/while.t t/spec/S04-statements/with.t t/spec/S05-capture/alias.t t/spec/S05-capture/array-alias.t t/spec/S05-capture/caps.t t/spec/S05-capture/dot.t t/spec/S05-capture/external-aliasing.t t/spec/S05-capture/hash.t t/spec/S05-capture/match-object.t t/spec/S05-capture/named.t t/spec/S05-capture/subrule.t t/spec/S05-grammar/action-stubs.t t/spec/S05-grammar/example.t t/spec/S05-grammar/inheritance.t t/spec/S05-grammar/methods.t t/spec/S05-grammar/namespace.t t/spec/S05-grammar/parse_and_parsefile.t t/spec/S05-grammar/polymorphism.t t/spec/S05-grammar/protoregex.t t/spec/S05-grammar/protos.t t/spec/S05-grammar/signatures.t t/spec/S05-grammar/std.t t/spec/S05-grammar/ws.t t/spec/S05-interpolation/lexicals.t t/spec/S05-interpolation/regex-in-variable.t t/spec/S05-mass/charsets.t t/spec/S05-mass/named-chars.t t/spec/S05-mass/properties-block.t t/spec/S05-mass/properties-derived.t t/spec/S05-mass/properties-general.t t/spec/S05-mass/properties-script.t t/spec/S05-mass/recursive.t t/spec/S05-mass/rx.t t/spec/S05-mass/stdrules.t t/spec/S05-match/arrayhash.t t/spec/S05-match/blocks.t t/spec/S05-match/capturing-contexts.t t/spec/S05-match/make.t t/spec/S05-match/non-capturing.t t/spec/S05-match/perl.t t/spec/S05-match/positions.t t/spec/S05-metachars/closure.t t/spec/S05-metachars/line-anchors.t t/spec/S05-metachars/newline.t t/spec/S05-metachars/tilde.t t/spec/S05-metasyntax/angle-brackets.t t/spec/S05-metasyntax/assertions.t t/spec/S05-metasyntax/changed.t t/spec/S05-metasyntax/charset.t t/spec/S05-metasyntax/delimiters.t t/spec/S05-metasyntax/interpolating-closure.t t/spec/S05-metasyntax/litvar.t t/spec/S05-metasyntax/longest-alternative.t t/spec/S05-metasyntax/lookaround.t t/spec/S05-metasyntax/null.t t/spec/S05-metasyntax/proto-token-ltm.t t/spec/S05-metasyntax/regex.t t/spec/S05-metasyntax/repeat.t t/spec/S05-metasyntax/sequential-alternation.t t/spec/S05-metasyntax/single-quotes.t t/spec/S05-metasyntax/unicode-property-pair.t t/spec/S05-metasyntax/unknown.t t/spec/S05-modifier/continue.t t/spec/S05-modifier/counted-match.t t/spec/S05-modifier/counted.t t/spec/S05-modifier/exhaustive.t t/spec/S05-modifier/global.t t/spec/S05-modifier/ignorecase-and-ignoremark.t t/spec/S05-modifier/ignorecase.t t/spec/S05-modifier/ignoremark.t t/spec/S05-modifier/ii.t t/spec/S05-modifier/my.t t/spec/S05-modifier/overlapping.t t/spec/S05-modifier/perl5_0.t t/spec/S05-modifier/perl5_1.t t/spec/S05-modifier/perl5_2.t t/spec/S05-modifier/perl5_3.t t/spec/S05-modifier/perl5_4.t t/spec/S05-modifier/perl5_5.t t/spec/S05-modifier/perl5_6.t t/spec/S05-modifier/perl5_7.t t/spec/S05-modifier/perl5_8.t t/spec/S05-modifier/perl5_9.t t/spec/S05-modifier/pos.t t/spec/S05-modifier/ratchet.t t/spec/S05-modifier/repetition-exhaustive.t t/spec/S05-modifier/repetition.t t/spec/S05-modifier/samemark.t t/spec/S05-modifier/sigspace.t t/spec/S05-nonstrings/basic.t t/spec/S05-substitution/67222.t t/spec/S05-substitution/match.t t/spec/S05-substitution/subst.t t/spec/S05-syntactic-categories/new-symbols.t t/spec/S05-transliteration/79778.t t/spec/S05-transliteration/trans.t t/spec/S05-transliteration/with-closure.t t/spec/S06-advanced/caller.t t/spec/S06-advanced/callframe.t t/spec/S06-advanced/callsame.t t/spec/S06-advanced/lexical-subs.t t/spec/S06-advanced/recurse.t t/spec/S06-advanced/return.t t/spec/S06-advanced/return_function.t t/spec/S06-advanced/stub.t t/spec/S06-advanced/wrap.t t/spec/S06-currying/assuming-and-mmd.t t/spec/S06-currying/misc.t t/spec/S06-currying/named.t t/spec/S06-currying/positional.t t/spec/S06-currying/slurpy.t t/spec/S06-macros/errors.t t/spec/S06-macros/opaque-ast.t t/spec/S06-macros/postfix.t t/spec/S06-macros/quasi-blocks.t t/spec/S06-macros/returning-closure.t t/spec/S06-macros/returning-string.t t/spec/S06-macros/unquoting.t t/spec/S06-multi/by-trait.t t/spec/S06-multi/lexical-multis.t t/spec/S06-multi/positional-vs-named.t t/spec/S06-multi/proto.t t/spec/S06-multi/redispatch.t t/spec/S06-multi/subsignature.t t/spec/S06-multi/syntax.t t/spec/S06-multi/type-based.t t/spec/S06-multi/unpackability.t t/spec/S06-multi/value-based.t t/spec/S06-operator-overloading/imported-subs.t t/spec/S06-operator-overloading/methods.t t/spec/S06-operator-overloading/semicolon.t t/spec/S06-operator-overloading/sub.t t/spec/S06-operator-overloading/term.t t/spec/S06-operator-overloading/workout.t t/spec/S06-other/anon-hashes-vs-blocks.t t/spec/S06-other/introspection.t t/spec/S06-other/main-eval.t t/spec/S06-other/main-semicolon.t t/spec/S06-other/main-usage.t t/spec/S06-other/main.t t/spec/S06-other/misc.t t/spec/S06-other/pairs-as-lvalues.t t/spec/S06-parameters/smiley.t t/spec/S06-routine-modifiers/lvalue-subroutines.t t/spec/S06-routine-modifiers/native-lvalue-subroutines.t t/spec/S06-routine-modifiers/proxy.t t/spec/S06-routine-modifiers/scoped-named-subs.t t/spec/S06-signature/arity.t t/spec/S06-signature/caller-param.t t/spec/S06-signature/closure-over-parameters.t t/spec/S06-signature/closure-parameters.t t/spec/S06-signature/code.t t/spec/S06-signature/defaults.t t/spec/S06-signature/definite-return.t t/spec/S06-signature/errors.t t/spec/S06-signature/introspection.t t/spec/S06-signature/mixed-placeholders.t t/spec/S06-signature/multi-invocant.t t/spec/S06-signature/multidimensional.t t/spec/S06-signature/multiple-signatures.t t/spec/S06-signature/named-parameters.t t/spec/S06-signature/named-placeholders.t t/spec/S06-signature/named-renaming.t t/spec/S06-signature/optional.t t/spec/S06-signature/outside-subroutine.t t/spec/S06-signature/passing-arrays.t t/spec/S06-signature/passing-hashes.t t/spec/S06-signature/positional-placeholders.t t/spec/S06-signature/positional.t t/spec/S06-signature/scalar-type.t t/spec/S06-signature/shape.t t/spec/S06-signature/sigilless.t t/spec/S06-signature/slurpy-and-interpolation.t t/spec/S06-signature/slurpy-blocks.t t/spec/S06-signature/slurpy-params.t t/spec/S06-signature/slurpy-placeholders.t t/spec/S06-signature/sub-ref.t t/spec/S06-signature/tree-node-parameters.t t/spec/S06-signature/type-capture.t t/spec/S06-signature/types.t t/spec/S06-signature/unpack-array.t t/spec/S06-signature/unpack-object.t t/spec/S06-signature/unspecified.t t/spec/S06-traits/as.t t/spec/S06-traits/is-assoc.t t/spec/S06-traits/is-copy.t t/spec/S06-traits/is-readonly.t t/spec/S06-traits/is-rw.t t/spec/S06-traits/misc.t t/spec/S06-traits/native-is-copy.t t/spec/S06-traits/native-is-rw.t t/spec/S06-traits/precedence.t t/spec/S06-traits/slurpy-is-rw.t t/spec/S07-iterators/range-iterator.t t/spec/S07-slip/slip.t t/spec/S09-autovivification/autoincrement.t t/spec/S09-autovivification/autovivification.t t/spec/S09-hashes/objecthash.t t/spec/S09-multidim/XX-POS-on-dimensioned.t t/spec/S09-multidim/XX-POS-on-undimensioned.t t/spec/S09-multidim/assign.t t/spec/S09-multidim/decl.t t/spec/S09-multidim/indexing.t t/spec/S09-multidim/methods.t t/spec/S09-subscript/multidim-assignment.t t/spec/S09-subscript/slice.t t/spec/S09-typed-arrays/arrays.t t/spec/S09-typed-arrays/hashes.t t/spec/S09-typed-arrays/native-decl.t t/spec/S09-typed-arrays/native-int.t t/spec/S09-typed-arrays/native-num.t t/spec/S09-typed-arrays/native.t t/spec/S10-packages/README t/spec/S10-packages/basic.t t/spec/S10-packages/export.t t/spec/S10-packages/joined-namespaces.t t/spec/S10-packages/nested-use.t t/spec/S10-packages/precompilation.t t/spec/S10-packages/require-and-use.t t/spec/S10-packages/scope.t t/spec/S10-packages/use-with-class.t t/spec/S11-modules/InnerModule.pm t/spec/S11-modules/OuterModule.pm t/spec/S11-modules/export.t t/spec/S11-modules/import-multi.t t/spec/S11-modules/import-tag.t t/spec/S11-modules/import.t t/spec/S11-modules/importing.t t/spec/S11-modules/lexical.t t/spec/S11-modules/module-file.t t/spec/S11-modules/module.t t/spec/S11-modules/need.t t/spec/S11-modules/nested.t t/spec/S11-modules/re-export.t t/spec/S11-modules/require.t t/spec/S11-modules/use-perl-6.t t/spec/S12-attributes/augment-and-initialization.t t/spec/S12-attributes/class.t t/spec/S12-attributes/clone.t t/spec/S12-attributes/defaults.t t/spec/S12-attributes/delegation.t t/spec/S12-attributes/inheritance.t t/spec/S12-attributes/instance.t t/spec/S12-attributes/mutators.t t/spec/S12-attributes/native.t t/spec/S12-attributes/recursive.t t/spec/S12-attributes/smiley.t t/spec/S12-attributes/trusts.t t/spec/S12-attributes/undeclared.t t/spec/S12-class/anonymous.t t/spec/S12-class/attributes-required.t t/spec/S12-class/attributes.t t/spec/S12-class/augment-supersede.t t/spec/S12-class/basic.t t/spec/S12-class/declaration-order.t t/spec/S12-class/extending-arrays.t t/spec/S12-class/inheritance-class-methods.t t/spec/S12-class/inheritance.t t/spec/S12-class/instantiate.t t/spec/S12-class/interface-consistency.t t/spec/S12-class/lexical.t t/spec/S12-class/literal.t t/spec/S12-class/magical-vars.t t/spec/S12-class/mro.t t/spec/S12-class/namespaced.t t/spec/S12-class/open.t t/spec/S12-class/open_closed.t t/spec/S12-class/parent_attributes.t t/spec/S12-class/rw.t t/spec/S12-class/self-inheritance.t t/spec/S12-class/stubs.t t/spec/S12-class/type-object.t t/spec/S12-coercion/coercion-types.t t/spec/S12-construction/BUILD.t t/spec/S12-construction/autopairs.t t/spec/S12-construction/construction.t t/spec/S12-construction/destruction.t t/spec/S12-construction/named-params-in-BUILD.t t/spec/S12-construction/new.t t/spec/S12-enums/anonymous.t t/spec/S12-enums/as-role.t t/spec/S12-enums/basic.t t/spec/S12-enums/misc.t t/spec/S12-enums/non-int.t t/spec/S12-enums/pseudo-functional.t t/spec/S12-enums/thorough.t t/spec/S12-introspection/WHAT.t t/spec/S12-introspection/attributes.t t/spec/S12-introspection/can.t t/spec/S12-introspection/definite.t t/spec/S12-introspection/meta-class.t t/spec/S12-introspection/methods.t t/spec/S12-introspection/parents.t t/spec/S12-introspection/roles.t t/spec/S12-introspection/walk.t t/spec/S12-meta/Declare.pm t/spec/S12-meta/DeclareBad.pm t/spec/S12-meta/InvalidDirective.pm t/spec/S12-meta/Supersede1.pm t/spec/S12-meta/Supersede2.pm t/spec/S12-meta/SupersedeBad.pm t/spec/S12-meta/exporthow.t t/spec/S12-meta/grammarhow.t t/spec/S12-meta/primitives.t t/spec/S12-methods/accessors.t t/spec/S12-methods/attribute-params.t t/spec/S12-methods/calling_sets.t t/spec/S12-methods/calling_syntax.t t/spec/S12-methods/chaining.t t/spec/S12-methods/class-and-instance.t t/spec/S12-methods/default-trait.t t/spec/S12-methods/defer-call.t t/spec/S12-methods/defer-next.t t/spec/S12-methods/delegation.t t/spec/S12-methods/fallback.t t/spec/S12-methods/how.t t/spec/S12-methods/indirect_notation.t t/spec/S12-methods/instance.t t/spec/S12-methods/lastcall.t t/spec/S12-methods/lvalue.t t/spec/S12-methods/method-vs-sub.t t/spec/S12-methods/multi.t t/spec/S12-methods/parallel-dispatch.t t/spec/S12-methods/private.t t/spec/S12-methods/qualified.t t/spec/S12-methods/submethods.t t/spec/S12-methods/syntax.t t/spec/S12-methods/topic.t t/spec/S12-methods/trusts.t t/spec/S12-methods/typed-attributes.t t/spec/S12-methods/what.t t/spec/S12-subset/multi-dispatch.t t/spec/S12-subset/subtypes.t t/spec/S12-traits/basic.t t/spec/S12-traits/parameterized.t t/spec/S13-overloading/fallbacks-deep.t t/spec/S13-overloading/metaoperators.t t/spec/S13-overloading/multiple-signatures.t t/spec/S13-overloading/operators.t t/spec/S13-overloading/typecasting-long.t t/spec/S13-syntax/aliasing.t t/spec/S13-type-casting/methods.t t/spec/S14-roles/anonymous.t t/spec/S14-roles/attributes.t t/spec/S14-roles/basic.t t/spec/S14-roles/bool.t t/spec/S14-roles/composition.t t/spec/S14-roles/conflicts.t t/spec/S14-roles/crony.t t/spec/S14-roles/instantiation.t t/spec/S14-roles/lexical.t t/spec/S14-roles/mixin.t t/spec/S14-roles/namespaced.t t/spec/S14-roles/parameter-subtyping.t t/spec/S14-roles/parameterized-basic.t t/spec/S14-roles/parameterized-mixin.t t/spec/S14-roles/parameterized-type.t t/spec/S14-roles/stubs.t t/spec/S14-roles/submethods.t t/spec/S14-traits/attributes.t t/spec/S14-traits/package.t t/spec/S14-traits/routines.t t/spec/S14-traits/variables.t t/spec/S15-literals/identifiers.t t/spec/S15-literals/numbers.t t/spec/S15-nfg/case-change.t t/spec/S15-nfg/cgj.t t/spec/S15-nfg/concatenation.t t/spec/S15-nfg/crlf-encoding.t t/spec/S15-nfg/from-buf.t t/spec/S15-nfg/from-file.t t/spec/S15-nfg/grapheme-break-test-gen.p6 t/spec/S15-nfg/grapheme-break.t t/spec/S15-nfg/long-uni.t t/spec/S15-nfg/many-combiners.t t/spec/S15-nfg/many-threads.t t/spec/S15-nfg/mass-chars.t t/spec/S15-nfg/mass-equality.t t/spec/S15-nfg/mass-roundtrip-nfc.t t/spec/S15-nfg/mass-roundtrip-nfd.t t/spec/S15-nfg/mass-roundtrip-nfkc.t t/spec/S15-nfg/mass-roundtrip-nfkd.t t/spec/S15-nfg/regex.t t/spec/S15-nfg/test-gen.p6 t/spec/S15-normalization/nfc-0.t t/spec/S15-normalization/nfc-1.t t/spec/S15-normalization/nfc-2.t t/spec/S15-normalization/nfc-3.t t/spec/S15-normalization/nfc-4.t t/spec/S15-normalization/nfc-5.t t/spec/S15-normalization/nfc-6.t t/spec/S15-normalization/nfc-7.t t/spec/S15-normalization/nfc-8.t t/spec/S15-normalization/nfc-9.t t/spec/S15-normalization/nfc-sanity.t t/spec/S15-normalization/nfd-0.t t/spec/S15-normalization/nfd-1.t t/spec/S15-normalization/nfd-2.t t/spec/S15-normalization/nfd-3.t t/spec/S15-normalization/nfd-4.t t/spec/S15-normalization/nfd-5.t t/spec/S15-normalization/nfd-6.t t/spec/S15-normalization/nfd-7.t t/spec/S15-normalization/nfd-8.t t/spec/S15-normalization/nfd-9.t t/spec/S15-normalization/nfd-sanity.t t/spec/S15-normalization/nfkc-0.t t/spec/S15-normalization/nfkc-1.t t/spec/S15-normalization/nfkc-2.t t/spec/S15-normalization/nfkc-3.t t/spec/S15-normalization/nfkc-4.t t/spec/S15-normalization/nfkc-5.t t/spec/S15-normalization/nfkc-6.t t/spec/S15-normalization/nfkc-7.t t/spec/S15-normalization/nfkc-8.t t/spec/S15-normalization/nfkc-9.t t/spec/S15-normalization/nfkc-sanity.t t/spec/S15-normalization/nfkd-0.t t/spec/S15-normalization/nfkd-1.t t/spec/S15-normalization/nfkd-2.t t/spec/S15-normalization/nfkd-3.t t/spec/S15-normalization/nfkd-4.t t/spec/S15-normalization/nfkd-5.t t/spec/S15-normalization/nfkd-6.t t/spec/S15-normalization/nfkd-7.t t/spec/S15-normalization/nfkd-8.t t/spec/S15-normalization/nfkd-9.t t/spec/S15-normalization/nfkd-sanity.t t/spec/S15-normalization/test-gen.p6 t/spec/S15-string-types/NF-types.t t/spec/S15-string-types/NFK-types.t t/spec/S15-string-types/Str.t t/spec/S15-string-types/Uni.t t/spec/S15-unicode-information/unimatch-general.t t/spec/S15-unicode-information/uniname.t t/spec/S15-unicode-information/uniprop.t t/spec/S15-unicode-information/unival.t t/spec/S16-filehandles/argfiles.t t/spec/S16-filehandles/chmod.t t/spec/S16-filehandles/dir.t t/spec/S16-filehandles/filestat.t t/spec/S16-filehandles/filetest.t t/spec/S16-filehandles/io.t t/spec/S16-filehandles/io_in_for_loops.t t/spec/S16-filehandles/io_in_while_loops.t t/spec/S16-filehandles/mkdir_rmdir.t t/spec/S16-filehandles/open.t t/spec/S16-filehandles/unlink.t t/spec/S16-io/bare-say.t t/spec/S16-io/basic-open.t t/spec/S16-io/bom.t t/spec/S16-io/comb.t t/spec/S16-io/cwd.t t/spec/S16-io/getc.t t/spec/S16-io/handles-between-threads.t t/spec/S16-io/lines.t t/spec/S16-io/newline.t t/spec/S16-io/note.t t/spec/S16-io/print.t t/spec/S16-io/quoting-syntax.t t/spec/S16-io/say-and-ref.t t/spec/S16-io/say.t t/spec/S16-io/split.t t/spec/S16-io/supply.t t/spec/S16-io/test-data t/spec/S16-io/tmpdir.t t/spec/S16-io/words.t t/spec/S16-unfiled/getpeername.t t/spec/S16-unfiled/rebindstdhandles.t t/spec/S17-channel/basic.t t/spec/S17-channel/earliest.t t/spec/S17-lowlevel/lock.t t/spec/S17-lowlevel/thread-start-join-stress.t t/spec/S17-lowlevel/thread.t t/spec/S17-procasync/basic.t t/spec/S17-procasync/kill.t t/spec/S17-procasync/many-processes-no-close-stdin.t t/spec/S17-procasync/no-runaway-file-limit.t t/spec/S17-procasync/print.t t/spec/S17-promise/allof.t t/spec/S17-promise/anyof.t t/spec/S17-promise/basic.t t/spec/S17-promise/in.t t/spec/S17-promise/start.t t/spec/S17-promise/stress.t t/spec/S17-promise/then.t t/spec/S17-scheduler/at.t t/spec/S17-scheduler/basic.t t/spec/S17-scheduler/every.t t/spec/S17-scheduler/in.t t/spec/S17-scheduler/times.t t/spec/S17-supply/Channel.t t/spec/S17-supply/Promise.t t/spec/S17-supply/act.t t/spec/S17-supply/basic.t t/spec/S17-supply/batch.t t/spec/S17-supply/categorize.t t/spec/S17-supply/classify.t t/spec/S17-supply/delayed.t t/spec/S17-supply/do.t t/spec/S17-supply/elems.t t/spec/S17-supply/flat.t t/spec/S17-supply/from-list.t t/spec/S17-supply/grab.t t/spec/S17-supply/grep.t t/spec/S17-supply/interval.t t/spec/S17-supply/last.t t/spec/S17-supply/lines.t t/spec/S17-supply/list.t t/spec/S17-supply/map.t t/spec/S17-supply/max.t t/spec/S17-supply/merge.t t/spec/S17-supply/migrate.t t/spec/S17-supply/min.t t/spec/S17-supply/minmax.t t/spec/S17-supply/on-demand.t t/spec/S17-supply/on.t t/spec/S17-supply/reduce.t t/spec/S17-supply/reverse.t t/spec/S17-supply/rotor.t t/spec/S17-supply/schedule-on.t t/spec/S17-supply/sort.t t/spec/S17-supply/squish.t t/spec/S17-supply/stable.t t/spec/S17-supply/start.t t/spec/S17-supply/syntax.t t/spec/S17-supply/throttle.t t/spec/S17-supply/unique.t t/spec/S17-supply/wait.t t/spec/S17-supply/watch-path.t t/spec/S17-supply/words.t t/spec/S17-supply/zip-latest.t t/spec/S17-supply/zip.t t/spec/S19-command-line-options/01-dash-uppercase-i.t t/spec/S19-command-line-options/02-dash-n.t t/spec/S19-command-line-options/03-dash-p.t t/spec/S19-command-line-options/04-negation.t t/spec/S19-command-line-options/05-delimited-options.t t/spec/S19-command-line/arguments.t t/spec/S19-command-line/dash-e.t t/spec/S19-command-line/help.t t/spec/S19-command-line/repl.t t/spec/S22-package-format/local.t t/spec/S24-testing/0-compile.t t/spec/S24-testing/1-basic.t t/spec/S24-testing/2-force_todo.t t/spec/S24-testing/3-output.t t/spec/S24-testing/6-done_testing.t t/spec/S24-testing/line-numbers.t t/spec/S24-testing/test-data/README t/spec/S24-testing/test-data/line-number-cmp-ok.txt t/spec/S24-testing/test-data/line-number-dies-ok.txt t/spec/S24-testing/test-data/line-number-eval-dies-ok.txt t/spec/S24-testing/test-data/line-number-eval-lives-ok.txt t/spec/S24-testing/test-data/line-number-is-deeply.txt t/spec/S24-testing/test-data/line-number-is.txt t/spec/S24-testing/test-data/line-number-is_approx.txt t/spec/S24-testing/test-data/line-number-isa-ok.txt t/spec/S24-testing/test-data/line-number-isnt.txt t/spec/S24-testing/test-data/line-number-lives-ok.txt t/spec/S24-testing/test-data/line-number-nok.txt t/spec/S24-testing/test-data/line-number-ok.txt t/spec/S24-testing/test-data/line-number-throws-like.txt t/spec/S24-testing/test-data/todo-passed.txt t/spec/S24-testing/use_ok_test.pm t/spec/S26-documentation/01-delimited.t t/spec/S26-documentation/02-paragraph.t t/spec/S26-documentation/03-abbreviated.t t/spec/S26-documentation/04-code.t t/spec/S26-documentation/05-comment.t t/spec/S26-documentation/06-lists.t t/spec/S26-documentation/07-tables.t t/spec/S26-documentation/08-formattingcodes.t t/spec/S26-documentation/09-configuration.t t/spec/S26-documentation/10-doc-cli.t t/spec/S26-documentation/block-leading.t t/spec/S26-documentation/block-trailing.t t/spec/S26-documentation/module-comment.t t/spec/S26-documentation/multiline-leading.t t/spec/S26-documentation/multiline-trailing.t t/spec/S26-documentation/wacky.t t/spec/S26-documentation/why-both.t t/spec/S26-documentation/why-leading.t t/spec/S26-documentation/why-trailing.t t/spec/S28-named-variables/cwd.t t/spec/S28-named-variables/inc.t t/spec/S28-named-variables/slangs.t t/spec/S29-any/cmp.t t/spec/S29-any/isa.t t/spec/S29-context/die.t t/spec/S29-context/eval.t t/spec/S29-context/evalfile.t t/spec/S29-context/exit-in-if.t t/spec/S29-context/exit.t t/spec/S29-context/sleep.t t/spec/S29-conversions/hash.t t/spec/S29-conversions/ord_and_chr.t t/spec/S29-os/system.t t/spec/S32-array/adverbs.t t/spec/S32-array/bool.t t/spec/S32-array/create.t t/spec/S32-array/delete-adverb-native.t t/spec/S32-array/delete-adverb.t t/spec/S32-array/delete.t t/spec/S32-array/elems.t t/spec/S32-array/end.t t/spec/S32-array/exists-adverb.t t/spec/S32-array/keys_values.t t/spec/S32-array/kv.t t/spec/S32-array/pairs.t t/spec/S32-array/perl.t t/spec/S32-array/pop.t t/spec/S32-array/push.t t/spec/S32-array/rotate.t t/spec/S32-array/shift.t t/spec/S32-array/splice.t t/spec/S32-array/unshift.t t/spec/S32-basics/warn.t t/spec/S32-basics/xxKEY.t t/spec/S32-basics/xxPOS-native.t t/spec/S32-basics/xxPOS.t t/spec/S32-container/cat.t t/spec/S32-container/roundrobin.t t/spec/S32-container/stringify.t t/spec/S32-container/zip.t t/spec/S32-exceptions/misc.t t/spec/S32-hash/adverbs.t t/spec/S32-hash/antipairs.t t/spec/S32-hash/delete-adverb.t t/spec/S32-hash/delete.t t/spec/S32-hash/exists-adverb.t t/spec/S32-hash/exists.t t/spec/S32-hash/invert.t t/spec/S32-hash/keys_values.t t/spec/S32-hash/kv.t t/spec/S32-hash/pairs.t t/spec/S32-hash/perl.t t/spec/S32-hash/push.t t/spec/S32-hash/slice.t t/spec/S32-io/IO-Socket-Async.t t/spec/S32-io/IO-Socket-INET.bat t/spec/S32-io/IO-Socket-INET.pl t/spec/S32-io/IO-Socket-INET.sh t/spec/S32-io/IO-Socket-INET.t t/spec/S32-io/chdir.t t/spec/S32-io/copy.t t/spec/S32-io/dir.t t/spec/S32-io/empty.txt t/spec/S32-io/file-tests.t t/spec/S32-io/io-handle.t t/spec/S32-io/io-path-cygwin.t t/spec/S32-io/io-path-unix.t t/spec/S32-io/io-path-win.t t/spec/S32-io/io-path.t t/spec/S32-io/io-spec-cygwin.t t/spec/S32-io/io-spec-unix.t t/spec/S32-io/io-spec-win.t t/spec/S32-io/mkdir_rmdir.t t/spec/S32-io/move.t t/spec/S32-io/note.t t/spec/S32-io/other.t t/spec/S32-io/path.t t/spec/S32-io/pi.txt t/spec/S32-io/pipe.t t/spec/S32-io/rename.t t/spec/S32-io/slurp.t t/spec/S32-io/socket-test.bin t/spec/S32-io/spurt.t t/spec/S32-list/categorize.t t/spec/S32-list/classify.t t/spec/S32-list/combinations.t t/spec/S32-list/create.t t/spec/S32-list/end.t t/spec/S32-list/first-end-k.t t/spec/S32-list/first-end-p.t t/spec/S32-list/first-end-v.t t/spec/S32-list/first-end.t t/spec/S32-list/first-k.t t/spec/S32-list/first-p.t t/spec/S32-list/first-v.t t/spec/S32-list/first.t t/spec/S32-list/grep-k.t t/spec/S32-list/grep-kv.t t/spec/S32-list/grep-p.t t/spec/S32-list/grep-v.t t/spec/S32-list/grep.t t/spec/S32-list/head.t t/spec/S32-list/join.t t/spec/S32-list/map.t t/spec/S32-list/map_function_return_values.t t/spec/S32-list/minmax.t t/spec/S32-list/numbers.data t/spec/S32-list/permutations.t t/spec/S32-list/pick.t t/spec/S32-list/produce.t t/spec/S32-list/reduce.t t/spec/S32-list/repeated.t t/spec/S32-list/reverse.t t/spec/S32-list/roll.t t/spec/S32-list/rotor.t t/spec/S32-list/seq.t t/spec/S32-list/sort.t t/spec/S32-list/squish.t t/spec/S32-list/tail.t t/spec/S32-list/unique.t t/spec/S32-num/abs.t t/spec/S32-num/base.t t/spec/S32-num/complex.t t/spec/S32-num/cool-num.t t/spec/S32-num/exp.t t/spec/S32-num/expmod.t t/spec/S32-num/fatrat.t t/spec/S32-num/int.t t/spec/S32-num/is-prime.t t/spec/S32-num/log.t t/spec/S32-num/narrow.t t/spec/S32-num/pi.t t/spec/S32-num/polar.t t/spec/S32-num/polymod.t t/spec/S32-num/power.t t/spec/S32-num/rand.t t/spec/S32-num/rat.t t/spec/S32-num/real-bridge.t t/spec/S32-num/roots.t t/spec/S32-num/rounders.t t/spec/S32-num/rshift_pos_amount.t t/spec/S32-num/sign.t t/spec/S32-num/sqrt.t t/spec/S32-num/stringify.t t/spec/S32-num/unpolar.t t/spec/S32-scalar/defined.t t/spec/S32-scalar/perl.t t/spec/S32-scalar/undef.t t/spec/S32-str/append.t t/spec/S32-str/bool.t t/spec/S32-str/capitalize.t t/spec/S32-str/chomp.t t/spec/S32-str/chop.t t/spec/S32-str/comb.t t/spec/S32-str/contains.t t/spec/S32-str/encode.t t/spec/S32-str/ends-with.t t/spec/S32-str/fc.t t/spec/S32-str/flip.t t/spec/S32-str/indent.t t/spec/S32-str/index.t t/spec/S32-str/indices.t t/spec/S32-str/lc.t t/spec/S32-str/length.t t/spec/S32-str/lines.t t/spec/S32-str/numeric.t t/spec/S32-str/ords.t t/spec/S32-str/pack.t t/spec/S32-str/pos.t t/spec/S32-str/rindex.t t/spec/S32-str/samecase.t t/spec/S32-str/samemark.t t/spec/S32-str/split-simple.t t/spec/S32-str/split.t t/spec/S32-str/sprintf-b.t t/spec/S32-str/sprintf.t t/spec/S32-str/starts-with.t t/spec/S32-str/substr-eq.t t/spec/S32-str/substr-rw.t t/spec/S32-str/substr.t t/spec/S32-str/tc.t t/spec/S32-str/tclc.t t/spec/S32-str/trim.t t/spec/S32-str/uc.t t/spec/S32-str/unpack.t t/spec/S32-str/utf8-c8.t t/spec/S32-str/words.t t/spec/S32-temporal/Date.t t/spec/S32-temporal/DateTime-Instant-Duration.t t/spec/S32-temporal/DateTime.t t/spec/S32-temporal/calendar.t t/spec/S32-temporal/local.t t/spec/S32-temporal/time.t t/spec/S32-trig/TrigTestSupport t/spec/S32-trig/atan2.t t/spec/S32-trig/cos.t t/spec/S32-trig/cosec.t t/spec/S32-trig/cosech.t t/spec/S32-trig/cosh.t t/spec/S32-trig/cotan.t t/spec/S32-trig/cotanh.t t/spec/S32-trig/e.t t/spec/S32-trig/generate-tests.pl t/spec/S32-trig/pi.t t/spec/S32-trig/sec.t t/spec/S32-trig/sech.t t/spec/S32-trig/simple.t t/spec/S32-trig/sin.t t/spec/S32-trig/sinh.t t/spec/S32-trig/tan.t t/spec/S32-trig/tanh.t t/spec/S32-trig/trig_functions t/spec/TODO t/spec/fudge t/spec/fudgeall t/spec/integration/99problems-01-to-10.t t/spec/integration/99problems-11-to-20.t t/spec/integration/99problems-21-to-30.t t/spec/integration/99problems-31-to-40.t t/spec/integration/99problems-41-to-50.t t/spec/integration/99problems-51-to-60.t t/spec/integration/99problems-61-to-70.t t/spec/integration/advent2009-day01.t t/spec/integration/advent2009-day02.t t/spec/integration/advent2009-day03.t t/spec/integration/advent2009-day04.t t/spec/integration/advent2009-day05.t t/spec/integration/advent2009-day06.t t/spec/integration/advent2009-day07.t t/spec/integration/advent2009-day08.t t/spec/integration/advent2009-day09.t t/spec/integration/advent2009-day10.t t/spec/integration/advent2009-day11.t t/spec/integration/advent2009-day12.t t/spec/integration/advent2009-day13.t t/spec/integration/advent2009-day14.t t/spec/integration/advent2009-day15.t t/spec/integration/advent2009-day16.t t/spec/integration/advent2009-day17.t t/spec/integration/advent2009-day18.t t/spec/integration/advent2009-day19.t t/spec/integration/advent2009-day20.t t/spec/integration/advent2009-day21.t t/spec/integration/advent2009-day22.t t/spec/integration/advent2009-day23.t t/spec/integration/advent2009-day24.t t/spec/integration/advent2010-day03.t t/spec/integration/advent2010-day04.t t/spec/integration/advent2010-day06.t t/spec/integration/advent2010-day07.t t/spec/integration/advent2010-day08.t t/spec/integration/advent2010-day10.t t/spec/integration/advent2010-day11.t t/spec/integration/advent2010-day12.t t/spec/integration/advent2010-day14.t t/spec/integration/advent2010-day16.t t/spec/integration/advent2010-day19.t t/spec/integration/advent2010-day21.t t/spec/integration/advent2010-day22.t t/spec/integration/advent2010-day23.t t/spec/integration/advent2011-day03.t t/spec/integration/advent2011-day04.t t/spec/integration/advent2011-day05.t t/spec/integration/advent2011-day07.t t/spec/integration/advent2011-day10.t t/spec/integration/advent2011-day11.t t/spec/integration/advent2011-day14.t t/spec/integration/advent2011-day15.t t/spec/integration/advent2011-day16.t t/spec/integration/advent2011-day20.t t/spec/integration/advent2011-day22.t t/spec/integration/advent2011-day23.t t/spec/integration/advent2011-day24.t t/spec/integration/advent2012-day02.t t/spec/integration/advent2012-day03.t t/spec/integration/advent2012-day04.t t/spec/integration/advent2012-day06.t t/spec/integration/advent2012-day09.t t/spec/integration/advent2012-day10.t t/spec/integration/advent2012-day12.t t/spec/integration/advent2012-day13.t t/spec/integration/advent2012-day14.t t/spec/integration/advent2012-day15.t t/spec/integration/advent2012-day16.t t/spec/integration/advent2012-day19.t t/spec/integration/advent2012-day20.t t/spec/integration/advent2012-day21.t t/spec/integration/advent2012-day22.t t/spec/integration/advent2012-day23.t t/spec/integration/advent2012-day24.t t/spec/integration/advent2013-day02.t t/spec/integration/advent2013-day04.t t/spec/integration/advent2013-day06.t t/spec/integration/advent2013-day07.t t/spec/integration/advent2013-day08.t t/spec/integration/advent2013-day09.t t/spec/integration/advent2013-day10.t t/spec/integration/advent2013-day12.t t/spec/integration/advent2013-day14.t t/spec/integration/advent2013-day15.t t/spec/integration/advent2013-day18.t t/spec/integration/advent2013-day19.t t/spec/integration/advent2013-day20.t t/spec/integration/advent2013-day21.t t/spec/integration/advent2013-day22.t t/spec/integration/advent2013-day23.t t/spec/integration/advent2014-day05.t t/spec/integration/advent2014-day13.t t/spec/integration/advent2014-day16.t t/spec/integration/code-blocks-as-sub-args.t t/spec/integration/error-reporting.t t/spec/integration/lazy-bentley-generator.t t/spec/integration/lexical-array-in-inner-block.t t/spec/integration/lexicals-and-attributes.t t/spec/integration/man-or-boy.t t/spec/integration/method-calls-and-instantiation.t t/spec/integration/no-indirect-new.t t/spec/integration/packages.t t/spec/integration/pair-in-array.t t/spec/integration/passing-pair-class-to-sub.t t/spec/integration/precompiled.t t/spec/integration/real-strings.t t/spec/integration/role-composition-vs-attribute.t t/spec/integration/rule-in-class-Str.t t/spec/integration/say-crash.t t/spec/integration/substr-after-match-in-gather-in-for.t t/spec/integration/topic_in_double_loop.t t/spec/integration/variables-in-do.t t/spec/integration/weird-errors.t t/spec/packages/A.pm t/spec/packages/A/A.pm t/spec/packages/A/B.pm t/spec/packages/Advent/GrammarProfiler.pm t/spec/packages/Advent/MetaBoundaryAspect.pm t/spec/packages/Advent/SingleInheritance.pm t/spec/packages/ArrayInit.pm t/spec/packages/B.pm t/spec/packages/B/Grammar.pm t/spec/packages/Bar.pm t/spec/packages/Baz.pm t/spec/packages/ContainsUnicode.pm t/spec/packages/Example/A.pm t/spec/packages/Example/B.pm t/spec/packages/Example/C.pm t/spec/packages/Export_PackA.pm t/spec/packages/Export_PackB.pm t/spec/packages/Export_PackC.pm t/spec/packages/Export_PackD.pm t/spec/packages/Exportops.pm t/spec/packages/Fancy/Utilities.pm t/spec/packages/Foo.pm t/spec/packages/FooBar.pm t/spec/packages/HasMain.pm t/spec/packages/Import.pm t/spec/packages/LoadCounter.pm t/spec/packages/LoadFromInsideAClass.pm t/spec/packages/LoadFromInsideAModule.pm t/spec/packages/OverrideTest.pm t/spec/packages/PM6.pm6 t/spec/packages/PackageTest.pm t/spec/packages/README t/spec/packages/RT123276.pm t/spec/packages/RT123276/B/C1.pm t/spec/packages/RT123276/B/C2.pm t/spec/packages/RT125715.pm6 t/spec/packages/RT76456.pm t/spec/packages/RT76606.pm t/spec/packages/RT76606/a.pm t/spec/packages/RT83354_A.pm t/spec/packages/RT83354_B.pm t/spec/packages/RT84280.pm t/spec/packages/RequireAndUse1.pm t/spec/packages/RequireAndUse2.pm t/spec/packages/RequireAndUse3.pm t/spec/packages/RoleA.pm t/spec/packages/RoleB.pm t/spec/packages/S11-modules/Foo.pm t/spec/packages/Test/Assuming.pm t/spec/packages/Test/Compile.pm t/spec/packages/Test/Idempotence.pm t/spec/packages/Test/Tap.pm t/spec/packages/Test/Util.pm t/spec/packages/UseTest.pm t/spec/rosettacode/README t/spec/rosettacode/greatest_element_of_a_list.t t/spec/rosettacode/sierpinski_triangle.t t/spec/t/01-implname.in t/spec/t/01-implname.out_impl-1 t/spec/t/01-implname.out_impl-2 t/spec/t/02-version.in t/spec/t/02-version.out_v6.0.0 t/spec/t/02-version.out_v6.0.3 t/spec/t/02-version.out_v6.1.0 t/spec/t/03-count.in t/spec/t/03-count.out_v6.0.0 t/spec/t/04-combinations.in t/spec/t/04-combinations.out_impl.1 t/spec/t/04-combinations.out_impl.2 t/spec/t/05-skip.in t/spec/t/05-skip.out_impl-1 t/spec/t/06-todo.in t/spec/t/06-todo.out_impl-1 t/spec/t/07-register_function.in t/spec/t/07-register_function.out_impl-1 t/spec/t/README t/spec/t/fudge.t t/spec/test_summary t/spectest.data tools/autounfudge.pl tools/available-pm-names.pl6 tools/benchmark.pl tools/build-localtest.pl tools/build/Makefile-JVM.in tools/build/Makefile-Moar.in tools/build/Makefile-common-macros.in tools/build/Makefile-common-rules.in tools/build/NQP_REVISION tools/build/check-versions.pl tools/build/common_bootstrap_sources tools/build/create-jvm-runner.pl tools/build/create-moar-runner.pl tools/build/gen-cat.nqp tools/build/gen-version.pl tools/build/makeSLICE.pl6 tools/build/moar_core_sources tools/build/nqp-jvm-rr.pl tools/commit-stats.pl tools/contributors.pl6 tools/lib/NQP/Configure.pm tools/perl6-limited.pl tools/progress-graph.pl tools/rakudo-swarm.config tools/release-dates.pl tools/update-passing-test-data.pl tools/update-tai-utc.pl tools/util/perlcritic.conf rakudo-2015.11/README.md000644 000765 000024 00000014174 12573566321 016421 0ustar00williamcoledastaff000000 000000 # Rakudo Perl 6 This is Rakudo Perl, a Perl 6 compiler for the MoarVM and JVM. Rakudo Perl is Copyright (C) 2008-2015, The Perl Foundation. Rakudo Perl is distributed under the terms of the Artistic License 2.0. For more details, see the full text of the license in the file LICENSE. This directory contains only the Rakudo Perl 6 compiler itself; it does not contain any of the modules, documentation, or other items that would normally come with a full Perl 6 distribution. If you're after more than just the bare compiler, please download [the latest Rakudo Star package](http://rakudo.org/downloads/star). Note that different backends implement slightly different sets of features. For a high-level overview of implemented and missing features, please visit [the features page on perl6.org](http://perl6.org/compilers/features). Recent changes and feature additions are documented in the `doc/ChangeLog` text file. ## Building and Installing Rakudo [![Build Status](https://travis-ci.org/rakudo/rakudo.svg?branch=nom)](https://travis-ci.org/rakudo/rakudo) See the INSTALL.txt file for detailed prerequisites and build and installation instructions. The general process for building is running `perl Configure.pl` with the desired configuration options (common options listed below), and then running `make` or `make install`. Optionally, you may run `make spectest` to test your build on [Roast](http://github.com/perl6/roast), the Official Perl 6 test suite. Installation of Rakudo simply requires building and running `make install`. Note that this step is necessary for running Rakudo from outside the build directory. But don't worry, it installs locally by default, so you don't need any administrator privileges for carrying out this step. ### Configuring Rakudo to run on MoarVM To automatically download and build a fresh MoarVM and NQP, run: perl Configure.pl --gen-moar --gen-nqp --backends=moar ### Configuring Rakudo to run on the JVM Note that to run Rakudo on JVM, JDK 1.7 must be installed. To automatically download an build a fresh NQP, run: perl Configure.pl --gen-nqp --backends=jvm If you get an out of memory error building rakudo on the JVM, you may need to modify your NQP runner to limit memory use. e.g. edit the nqp-j / nqp-j.bat executable (found wherever you installed to, or in the `install/bin` directory) to include `-Xms500m -Xmx2g` as options passed to java. ### Multiple backends at the same time By supplying combinations of backends to the `--backends` flag, you can get two or three backends built in the same prefix. The first backend you supply in the list is the one that gets the `perl6` name as a symlink, and all backends are installed seperately as `perl6-m` or `perl6-j` for Rakudo on MoarVM, or JVM respectively. The format for the `--backends` flag is: $ perl Configure.pl --backends=moar,jvm $ perl Configure.pl --backends=ALL ## Where to get help or answers to questions There are several mailing lists, IRC channels, and wikis available with help for Perl 6 and Rakudo. Figuring out the right one to use is often the biggest battle. Here are some rough guidelines: The central hub for Perl 6 information is [perl6.org](http://perl6.org/). This is always a good starting point. If you have a question about Perl 6 syntax or the right way to approach a problem using Perl 6, you probably want the "perl6-users@perl.org" mailing list or the "irc.freenode.net/#perl6" channel. The perl6-users list is primarily for the people who want to use Perl 6 to write programs, so newbie questions are welcomed there. Newbie questions are also welcome on the #perl6 channel; the Rakudo and Perl 6 development teams tend to hang out there and are generally glad to help. You can follow "@rakudoperl" on Twitter, and there's a Perl 6 news aggregator at [Planet Perl 6](http://pl6anet.org/). Questions about NQP can also be posted to the #perl6 IRC channel. For questions about MoarVM, you can join #moarvm on freenode. ## Reporting bugs Bug reports should be sent to "rakudobug@perl.org" with the moniker [BUG]\(including the brackets) at the start of the subject so that it gets appropriately tagged in [the RT system](https://rt.perl.org/rt3/). Please include or attach any sample source code that exhibits the bug, and include either the release name/date or the git commit identifier. You find that information in the output from `perl6 --version` (or in the first line of `git log`, if Rakudo fails to build). There's no need to cc: the perl6-compiler mailing list, as the RT system will handle this on its own. If you find a bug in MoarVM or NQP, you can either discuss it on the IRC and have it reported for you, or you can submit an issue to the issue trackers on github for perl6/nqp or moarvm/moarvm. ## Submitting patches If you have a patch that fixes a bug or adds a new feature, please submit it to "rakudobug@perl.org" with the moniker [PATCH]\(including the brackets) at the start of the subject line. We'll generally accept patches in any form if we can get them to work, but unified diff from the `git` command is greatly preferred. In general this means that in the "rakudo" directory you make your changes, and then type git commit -m 'Your commit message' changed/filename.pm git format-patch HEAD^ This will generate a file called "001-your-commit-message.patch", or more of them if you made multiple commits; please attach these to your email. Please note that if you made more than one commit, you have to specify a proper commit range for format-patch, for example `origin/nom..HEAD`. (Note to the maintainers: you can apply these patches with the `git-am -s` command; it preserves meta information like author). ## Line editing and tab completion If you would like simple history and tab completion in the perl6 executable, you need to install the Linenoise module. The recommended way to install Linenoise is via [panda](https://github.com/tadzik/panda): panda install Linenoise ## How the compiler works See `docs/compiler_overview.pod`. ## AUTHOR Patrick Michaud "pmichaud@pobox.com" is the current pumpking for Rakudo Perl 6. See CREDITS for the many people that have contributed to the development of the Rakudo compiler. rakudo-2015.11/VERSION000644 000765 000024 00000000010 12623477422 016171 0ustar00williamcoledastaff000000 000000 2015.11 rakudo-2015.11/blib/Perl6/.gitignore000644 000765 000024 00000000026 12573545400 021014 0ustar00williamcoledastaff000000 000000 *.pbc *.class *.moarvmrakudo-2015.11/docs/ChangeLog000644 000765 000024 00000261720 12623477243 017645 0ustar00williamcoledastaff000000 000000 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 rakudo-2015.11/docs/ROADMAP000644 000765 000024 00000005315 12600026747 017067 0ustar00williamcoledastaff000000 000000 Rakudo Roadmap -------------- Last updated: 2015-07-26 This document serves as a guide to the major goals for Rakudo development, as things stood in December 2011. They have been roughly categorized. Each has been given a 1-3 priority indicator, where 1 is "fairly pressing", 2 is "desirable", and 3 is "wanted, but not a key goal right now". Each item also has from one to five asterisks indicating the estimated "degree of effort" required for the item. A lower priority does not mean, "don't work on this". If you want to hack on a priority 3 item, go right ahead. It is, after all, wanted. And things that are priority 3 now will eventually work their way up to the top anyway. Mostly, -Ofun. Some items are marked with the names of people likely to either work on them OR serve as a "contact person" for the goal. Again, don't let a name already being against a goal stop you working on it - though it would be wise that you check where the marked person is at with it to avoid any duplicated effort, or to pick up hints about how to jump in. :-) Patches to this document are welcome - to add missing goals, remove completed ones, re-prioritize, volunteer for a goal, rescue yourself from a goal, etc. Compiler Performance/Portability Improvements (jnthn) 3 ** Optimizing multis for `[+] 1..10` and `[<=] 1..10` etc. Macros (masak) 2 ** hygienic macros and the COMPILING:: pseudopackage 2 **** "delayed" declarations of routines and types within quasiquotes 3 ? Textual macros Operators 3 ** logical cascades Regexes 2 ** ~~ inside regexes 2 * @< > (force a capture to be an array) 3 ** <*foo> 3 ** <~~0>, <~~foo> 3 *** explicit backtracking control (::, :::) 3 ** and Built-ins/Data Structures 2 *** packed arrays (jnthn) 2 ** Rat/FatRat/Rational cleanup 2 ** sized/shaped arrays (jnthn) 2 ** Correct type smiley support (:U, :D, etc.) (jnthn) 3 *** arrays with custom keys 3 *** complete LoL and slice context implementation 3 *** Cat and stream matching Language Features 2 * $=DATA and friends (tadzik) 2 ** module versioning (lizmat,FROGGS) 2 *** new syntax/semantics for coercion (jnthn) 3 *** domain specific languages -- slang and grammar tweaks (FROGGS) 3 **** more advanced Perl 5 interop (lexical embedding, etc.) (FROGGS) 2 ** label handling using goto 2 ? leave for leading blocks Optimizer (jnthn) 2 ** ro/rw variable tracking, related transforms 2 ** context/non-context variable tracking 2 *** :D/:U constraint tracking and integration with dispatch analysis 2 * topic preservation elimination on simple block inlines Other things (to be organized into above groups) 3 ? AUTOLOAD, including possibly AUTOLOADING setting components rakudo-2015.11/docs/S11-Modules-proposal.pod000644 000765 000024 00000012100 12573545400 022363 0ustar00williamcoledastaff000000 000000 =head1 S11-Modules proposal for Rakudo * implementation The aim will be to implement it all in NQP if possible. =head1 Overriding Principle The source code must always be the absolute source of all information. Everything else should act as a cache. That means *.pir files and databases of metadata may be automatically or manually derived from the *.pm files, but they may not add information (from the command line, for example). If there is to be cached metadata in future, it should be stored in files as close to the corresponding source files as possible. If modules are precompiled to *.pir files, those files will be stored in the same directories as their corresponding *.pm source files, with identical names apart from the extension. =head1 Restrictions and limitations =head2 No C keyword Classes may contain other classes, which provides sufficient hierarchy. Rakudo will implement C, in order to contain sub definitions that do not belong to any class. =head2 Only simplest :ver and :auth implementation There should be only one C<:ver> and C<:auth> name part per source code file, in order to keep the implementation simple. In order to keep users sane, multiple C<:ver> or C<:auth> name parts in the same source file will make the using program die with a NYI error. The following is ok (loaded by "use Foo::Bar:ver<1.2.3>:auth"): # in Foo/Bar.pm class Foo::Bar:ver<1.2.3>:auth { # or module, grammar etc ... class Baz { ... } } The following (nested class declarations) will not be implemented in Rakudo *: # in Foo.pm module Foo { # or class Foo, grammar Foo etc class Bar:ver<1.2.3>:auth { ... } } =head2 No Unicode mangling in file names If you want to use Unicode in your module names, your file system must support Unicode as well. If you want users without Unicode file names to use your modules, don't use Unicode in your module names. =head2 Retain @*INC to specify where searching begins Rakudo effectively gives the following output to -e'.say for @*INC' ~/.perl6/lib parrot_install/lib/2.1.0-devel/share/perl6/lib . The . entry may be removed from the default @*INC because it creates a security risk, but it is needed in the medium term for the build process to conveniently find F. Unlike the Perl 5 case, all matching candidate files in all applicable directories will be considered, so in most cases the order of directories in @*INC is not significant. If copies of the same module name with the same C<:auth> and C<:ver> name parts exist in the same or even different directories, Rakudo may arbitrarily use any one of those files and ignore the others. The module installer utility should try to prevent such duplication arising, but should tolerate it if it already exists. =head2 Room for wriggling on file names If multiple instances of a module exist, they may be distributed among all the @*INC directories. Folders correspond to packages (aka namespaces) and they are not allowed to have :ver and :auth name parts. In every directory, file name collisions are avoided by optionally inserting a unique .infix in the name before the .pm extension. The following would all match a C command: Foo.pm Foo.1.pm Foo.12345.pm Currently only digits are being considered, but anything within reason between the two dots should be allowed, and is under the control of the module installer. The infix characters are meaningless. Only the code inside the file specifies :ver and :auth. =head1 Searches in C, C and C commands In commands such as C, the :auth and :ver name parts are independently optional. Rakudo * will do only exact matches on :auth and :ver name parts, because the alternative gives headaches... Consider the example "use Foo::Bar:ver<1.2.3>:auth" Rakudo * will look for files matching Foo/Bar.pm and Foo/Bar.*.pm from every starting point listed in @*INC. Rakudo will then open each file in turn and partially (how?) parse the content to extract the first :ver and :auth values, building a list of the results. Caching will probably be added soon after the initial implementation works, in order to reduce the obvious overheads. If the C specified an C<:auth> or a C<:ver>, the values must match, and non-matching files are disqualified. Rakudo will consider files in the user's local directories (. and ~/.perl6/lib) that omit :auth and :ver values. Modules in the parrot_install tree should all have :auth and :ver. If the :ver is not specified, Rakudo must select the file containing the highest :ver value. Files without :ver are considered as having the lowest possible :ver value. Multiple files without :ver, or multiple files with the same :ver, will result in an arbitrary selection. =head1 Implementation notes There is a Perl 5 stub implementation of the module finding algorithm in the rmp repository L in the file C. Commit bits to that repo are handed out freely; just ask hugme on #perl6 :-). rakudo-2015.11/docs/announce/2009-02000644 000765 000024 00000006071 12573545400 020424 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl development release #14 ("Vienna") On behalf of the Rakudo development team, I'm pleased to announce the February 2009 development release of Rakudo Perl #14 "Vienna". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the February 2009 release is available from http://www.pmichaud.com/perl6/rakudo-2009-02.tar.gz However, because of the rapid pace of Rakudo development and addition of new features, we still recommend that people wanting to use or work with Rakudo obtain the latest version directly from the main repository at github -- more on this in a bit. This is the fourteenth development release of Rakudo Perl, but it's the first release independent from Parrot releases. We will continue to follow a monthly release cycle, with each release to be code named after a Perl Mongers group. This release is named for Vienna.pm (http://vienna.pm.org), who have been sponsoring Jonathan Worthington's work on Rakudo since April 2008. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Rakudo Perl now uses git [2] for its version control system, hosted at http://github.com/rakudo/rakudo . The README file there is kept up-to-date with the latest instructions for obtaining and building Rakudo Perl. In this release of Rakudo Perl, we've made the following major changes and improvements: * Rakudo is now passing 7076 spectests. This is an increase of 796 passing tests since the January 2009 release. * The Configure.pl script supports a "--gen-parrot" option to automatically fetch and build the appropriate version of Parrot. * The default make target now builds a binary executable directly, either perl6 or perl6.exe. It's still a Parrot "fakecutable", but we think we've made it more reliable so that it doesn't generate segmentation faults on exits. (If you don't know what a "fakecutable" is you can safely ignore this.) * Many builtins are beginning to be written in pure Perl 6, or Perl 6 functions with inline PIR. These builtins are part of the core "setting" for Perl 6, and appear in the src/setting/ directory. Previously this was known as the "prelude". * Improved Test.pm diagnostic output. Also, Rakudo now implements the following Perl 6 features: * Anonymous classes may be specified using :: * Existing parameterized roles are now reused instead of creating new ones. * Roles pun a class when .new is invoked on them. * "proto" now marks all same-named routines as "multi". * "XopX" is now "Xop". * <-> (rw) pointy blocks. * min= and max= metaoperators. * Many many bugfixes and documentation improvements. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. The next release of Rakudo (#15) is scheduled for March 19, 2009. References: [1] Parrot, http://parrot.org/ [2] Git version control system, http://git-scm.org/ rakudo-2015.11/docs/announce/2009-03000644 000765 000024 00000005011 12573545400 020416 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl development release #15 ("Oslo") On behalf of the Rakudo development team, I'm pleased to announce the March 2009 development release of Rakudo Perl #15 "Oslo". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the March 2009 release is available from http://www.pmichaud.com/perl6/rakudo-2009-03.tar.gz However, because of the rapid pace of Rakudo development and addition of new features, we still recommend that people wanting to use or work with Rakudo obtain the latest version directly from the main repository at github -- more on this in a bit. Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. This release is named "Oslo" in honor of the organizers of the 2009 Nordic Perl Workshop [2], April 16-17, 2009. The 2009 Nordic Perl Workshop will have a special focus on Perl 6, Rakudo Perl, and Parrot, including Perl 6 tutorials and hackathons after the conference itself. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Rakudo Perl now uses git [3] for its version control system, hosted at http://github.com/rakudo/rakudo . The README file there is kept up-to-date with the latest instructions for obtaining and building Rakudo Perl. In this release of Rakudo Perl, we've made the following major changes and improvements: * Rakudo is now passing 7273 spectests. This is an increase of 197 passing tests since the February 2009 release. * The eval() construct now understands lexical variables from an outer scope. * More of the builtin functions ("settings") are being written in Perl 6. * Rakudo supports the "R" (reverse) metaoperator. * Parsing of if, unless, while, until, etc. statements after blocks now works correctly. * The Q quote operator is now implemented, along with several adverbial forms. In particular, the Q:PIR form allows inline PIR to be included in Perl 6 code. * Multi-method dispatch now works with inheritance also. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. The next release of Rakudo (#16) is scheduled for April 23, 2009. References: [1] Parrot, http://parrot.org/ [2] Nordic Perl Workshop 2009, http://www.perlworkshop.no/npw2009/ [3] Git version control system, http://git-scm.org/ rakudo-2015.11/docs/announce/2009-04000644 000765 000024 00000006343 12573545400 020430 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #16 ("Bratislava") On behalf of the Rakudo development team, I'm pleased to announce the April 2009 development release of Rakudo Perl #16 "Bratislava". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the April 2009 release is available from http://github.com/rakudo/rakudo/downloads . Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we continue to recommend that people wanting to use or work with Rakudo obtain the latest source directly from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo . Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. This release is named "Bratislava", home to Jonathan Worthington and reportedly an excellent place to obtain beer (a key component of Jonathan's contributions to Perl). The Bratislava.pm group is quite active [2], with regular technical presentations and social gatherings. In this release of Rakudo Perl, we've made the following major changes and improvements: * Rakudo is now passing 10,467 spectests, an increase of 3,194 passing tests since the March 2009 release. With this release Rakudo is now passing approximately 65% of the available spectest suite. * About 2/3 of the increase in passing tests is due to improved Unicode support in Rakudo; constructs such as "\c[LATIN CAPITAL LETTER A]" and Unicode character properties in regexes are now supported. * The prefix:<=> operator is now gone from the Perl 6 specification (and thus from Rakudo). Use .get for reading individual items from iterators. * Rakudo now supports typed arrays and hashes (my Int @array), as well as parametric versions of the Associative, Positional, and Callable roles, and parametric role subtyping. * Rakudo now has sockets support (IO::Socket). * Subroutine return types are now enforced in some cases. * Rakudo now supports lexical sub declarations. * Rakudo now supports some P5-style regexes. * The "quantify-by-separator" feature has been added, so that one can write / [\w+] ** ',' / to get a comma-separated list of words. * More builtin functions and methods have been rewritten in Perl 6 and placed as part of the setting. * Release tar files now contain local copies of the appropriate spectests, instead of obtaining checkout copies via Subversion. * There are additional improvements and features in this release, see docs/ChangeLog for a more complete list. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#17) is scheduled for May 21, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! References: [1] Parrot, http://parrot.org/ [2] Bratislava.pm, http://bratislava.pm.org/ rakudo-2015.11/docs/announce/2009-05000644 000765 000024 00000005647 12573545400 020437 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #17 ("Stockholm") On behalf of the Rakudo development team, I'm pleased to announce the May 2009 development release of Rakudo Perl #17 "Stockholm". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the May 2009 release is available from http://github.com/rakudo/rakudo/downloads . Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we continue to recommend that people wanting to use or work with Rakudo obtain the latest source directly from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo . Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. This release is named "Stockholm"; Stockholm Perl Mongers will be holding a Perl 6 hackathon on May 29 [3]. Perl 6 developer Carl Mäsak is a member of Stockholm Perl Mongers and a main author of November [4], Druid [5], proto [6], and other Perl 6-based packages. Carl also contributes patches to Rakudo, and has been stress-testing Rakudo over the past year, submitting nearly 400 bug reports. In this release of Rakudo Perl, we've made the following major changes and improvements: * Rakudo is now passing 11,342 spectests, an increase of 875 passing tests since the April 2009 release. With this release Rakudo is now passing 68% of the available spectest suite. * We now have an updated docs/ROADMAP . * Errors and stack traces now report the file name and line number in the original source code. * Some custom operators can be defined, and it's possible to refer to operators using &infix: syntax. * We can start to load libraries written in other Parrot languages. * Regexes now produce a Regex sub. * More builtin functions and methods have been rewritten in Perl 6 and placed as part of the setting. * There are many additional improvements and features in this release, see docs/ChangeLog for a more complete list. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#18) is scheduled for June 18, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! References: [1] Parrot, http://parrot.org/ [2] Stockholm.pm, http://sthlm.pm.org/ [3] Stockholm Perl 6 hackathon, http://vic20.blipp.com/pipermail/kameler/2009-May/000318.html [4] November wiki engine, http://github.com/viklund/november/ [5] Druid, http://github.com/masak/druid/ [6] Proto, http://github.com/masak/proto/ rakudo-2015.11/docs/announce/2009-06000644 000765 000024 00000006511 12573545401 020430 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #18 ("Pittsburgh") On behalf of the Rakudo development team, I'm pleased to announce the June 2009 development release of Rakudo Perl #18 "Pittsburgh". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the June 2009 release is available from http://github.com/rakudo/rakudo/downloads . Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we continue to recommend that people wanting to use or work with Rakudo obtain the latest source directly from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo . Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. This release is named "Pittsburgh", which is the host for YAPC|10 (YAPC::NA 2009) [2] and the Parrot Virtual Machine Workshop [3]. Pittsburgh.pm has also sponsored hackathons for Rakudo Perl as part of the 2008 Pittsburgh Perl Workshop [4]. In this release of Rakudo Perl, we've focused our efforts on refactoring many of Rakudo's internals; these refactors improve performance, bring us closer to the Perl 6 specification, operate more cleanly with Parrot, and provide a stronger foundation for features to be implemented in the near future. Some of the specific major changes and improvements in this release include: * Rakudo is now passing 11,536 spectests, an increase of 194 passing tests since the May 2009 release. With this release Rakudo is now passing 68% of the available spectest suite. * Method dispatch has been substantially refactored; the new dispatcher is significantly faster and follows the Perl 6 specification more closely. * Object initialization via the BUILD and CREATE (sub)methods is substantially improved. * All return values are now type checked (previously only explicit 'return' statements would perform type checking). * String handling is significantly improved: fewer Unicode-related bugs exist, and parsing speed is greatly improved for some programs containing characters in the Latin-1 set. * The IO .lines and .get methods now follow the specification more closely. * User-defined operators now also receive some of their associated meta variants. * The 'is export' trait has been improved; more builtin functions and methods can be written in Perl 6 instead of PIR. * Many Parrot changes have improved performance and reduced overall memory leaks (although there's still much more improvement needed). The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#19) is scheduled for July 23, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! References: [1] Parrot, http://parrot.org/ [2] YAPC|10 http://yapc10.org/yn2009/ [3] Parrot Virtual Machine Workshop, http://yapc10.org/yn2009/talk/2045 [4] Pittsburgh Perl Workshop, http://pghpw.org/ppw2008/ rakudo-2015.11/docs/announce/2009-07000644 000765 000024 00000006124 12573545401 020431 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #19 ("Chicago") On behalf of the Rakudo development team, I'm pleased to announce the June 2009 development release of Rakudo Perl #19 "Chicago". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the July 2009 release is available from http://github.com/rakudo/rakudo/downloads . Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we continue to recommend that people wanting to use or work with Rakudo obtain the latest source directly from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo . Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. The July 2009 release is named "Chicago", as chosen by Perl 6 contributor Kyle Hasselbacher. Kyle has been doing a truly outstanding job of turning open tickets in the RT queues into tests for the spectest suite. Chicago.pm has been the host for the 2006 and 2008 YAPC::NA conferences and sponsored Perl 6 hackathons at each conference. In this release of Rakudo Perl, we've focused our efforts on quality improvements and bootstrapping. We now have operators and additional builtin functions written in Perl 6. Some of the specific major changes and improvements in this release include: * Rakudo is now passing 11,876 spectests, an increase of 340 passing tests since the June 2009 release. With this release Rakudo is now passing 68% of the available spectest suite. * Operators can now be written in Perl 6, and this has been done for the series operator '...', 'eqv' and the 'leg' operator. * The multi dispatcher has been refactored extensively, and now handles many more edge cases correctly. * User defined traits now follow the specification much more closely; some built-in traits are written in Perl 6. * Improved testing: Null PMC Access exceptions are never considered "successful" by the test suite, even if the test was expecting a (different) exception to be thrown. * Improved introspection: you can now get a list of roles composed into a class, and a list of attributes. Since the Perl 6 specification is still in flux, some deprecated features will be removed from Rakudo. Prominently among those are: * '=$handle' is deprecated in favor of '$handle.get' (one line) and '$handle.lines' (all lines). * 'int $obj' is deprecated in favor of '$obj.Int'. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#20) is scheduled for August 20, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! References: [1] Parrot, http://parrot.org/ rakudo-2015.11/docs/announce/2009-08000644 000765 000024 00000007161 12573545401 020434 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #20 ("PDX") On behalf of the Rakudo development team, I'm pleased to announce the August 2009 development release of Rakudo Perl #20 "PDX". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the August 2009 release is available from http://github.com/rakudo/rakudo/downloads . Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we continue to recommend that people wanting to use or work with Rakudo obtain the latest source directly from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo . Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. August 2009 is code named "PDX" for the Portland Perl Mongers. PDX.pm has been home to several Rakudo contributors (chromatic, Allison Randal, and more) and PDX.pm has held meetings that have produced feature and bugfix patches for Rakudo. Beginning with this release, Rakudo Perl builds from an "installed Parrot" instead of using Parrot's build tree. This release of Rakudo requires Parrot 1.5.0. For the latest information on building and using Rakudo Perl, see the README file section titled "Building and invoking Rakudo". (Quick note: the "--gen-parrot" option still automatically downloads and builds Parrot as before, if you prefer that approach.) Also, unlike previous versions of Rakudo Perl, the "perl6" (or "perl6.exe") executables only work when invoked from the Rakudo root directory until a "make install" is performed. Running "make install" will install Rakudo and its libraries into the Parrot installation that was used to build it, and then the executables will work when invoked from any directory. Some of the specific major changes and improvements occuring with this release include: * Rakudo is now passing 12,369 spectests, an increase of 493 passing tests since the July 2009 release. With this release Rakudo is now passing 69.98% of the available spectest suite. * We now have a much cleaner traits implementation. Many of the Perl 6 built-in traits are now implemented in Perl 6, and user-defined traits can now be defined and applied to classes and roles. * The 'hides' trait on classes can make one class hide another. * Many not-yet-implemented operators and features now provide more helpful error messages instead of simply producing parse errors. * The ROADMAP has been substantially updated and includes some details regarding the "Rakudo Star" release [2]. * Embedded comments now require backticks (Perl 6 specification change). Since the Perl 6 specification is still in flux, some deprecated features will be removed from Rakudo. Prominently among those are: * '=$handle' is deprecated in favor of '$handle.get' (one line) and '$handle.lines' (all lines). * 'int $obj' is deprecated in favor of '$obj.Int'. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#21) is scheduled for September 17, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! References: [1] Parrot, http://parrot.org/ [2] Rakudo Star, http://use.perl.org/~pmichaud/journal/39411 rakudo-2015.11/docs/announce/2009-09000644 000765 000024 00000006651 12573545401 020440 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #21 ("Seattle") On behalf of the Rakudo development team, I'm pleased to announce the September 2009 development release of Rakudo Perl #21 "Seattle". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine [1]. The tarball for the September 2009 release is available from http://github.com/rakudo/rakudo/downloads . Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we recommend building Rakudo from the latest source, available from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo. Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. September 2009 is code named "Seattle" for the enthusiasm they have shown for Perl 6 during monthly meetings, and the feedback, encouragement and support given me for the past several years. Since the 2009-08 release, Rakudo Perl builds from an "installed Parrot" instead of using Parrot's build tree. This release of Rakudo requires Parrot 1.6.0. For the latest information on building and using Rakudo Perl, see the README file section titled "Building and invoking Rakudo". (Quick note: the "--gen-parrot" option still automatically downloads and builds Parrot as before, if you prefer that approach.) Also, unlike previous versions of Rakudo Perl, the "perl6" (or "perl6.exe") executables only work when invoked from the Rakudo root directory until a "make install" is performed. Running "make install" will install Rakudo and its libraries into the Parrot installation that was used to build it, and then the executables will work when invoked from any directory. Some of the specific major changes and improvements occuring with this release include: * Rakudo is now passing 15,497 spectests, an increase of 3,128 passing tests since the August 2009 release. With this release Rakudo is now passing 71.5% of the available spectest suite. * Rakudo now supports contextual variables. * Rakudo now supports the rational (Rat) data type. * Rakudo now supports overloading of many of the builtin operators, many of which are now defined in the core setting. Many have also been improved to be more faithful to the specification with respect to types and coercions. * Substantially improved support for trait handling. Most of the "built-in" traits are now defined in the core setting. * The %*ENV variable now works properly for modifying the process environment. Since the Perl 6 specification is still in flux, some deprecated features have been removed from Rakudo. Prominently among those are: * '=$handle' is deprecated in favor of '$handle.get' (one line) and '$handle.lines' (all lines). * 'int $obj' is deprecated in favor of '$obj.Int'. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#22) is scheduled for October 22, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! References: [1] Parrot, http://parrot.org/ rakudo-2015.11/docs/announce/2009-10000644 000765 000024 00000006560 12573545401 020427 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #22 ("Thousand Oaks") On behalf of the Rakudo development team, I'm pleased to announce the October 2009 development release of Rakudo Perl #22 "Thousand Oaks". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the October 2009 release is available from http://github.com/rakudo/rakudo/downloads Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we recommend building Rakudo from the latest source, available from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo. Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. The October 2009 is code named "Thousand Oaks" for their amazing Perl 6 hackathon, their report at http://www.lowlevelmanager.com/2009/09/perl-6-hackathon.html, and just because I like the name :-) Since the 2009-08 release, Rakudo Perl builds from an installed Parrot instead of using Parrot's build tree. This means that, unlike previous versions of Rakudo Perl, the "perl6" (or "perl6.exe") executables only work when invoked from the Rakudo root directory until a "make install" is performed. Running "make install" will install Rakudo and its libraries into the Parrot installation that was used to build it, and then the executables will work when invoked from any directory. This release of Rakudo requires Parrot 1.7.0. For the latest information on building and using Rakudo Perl, see the readme file section titled "Building and invoking Rakudo". (Quick note: the "--gen-parrot" option still automatically downloads and builds Parrot as before, if you prefer that approach.) Some of the specific changes and improvements occuring with this release include: * Rakudo is now passing 32,582 spectests, an increase of 17,085 passing tests since the September 2009 release. With this release Rakudo is now passing 85.0% of the available spectest suite. * We have a huge increase in the number of spectests relating to the Complex and Rat numeric types. * Complex numbers are now implemented as a Perl 6 class, and supports all trigonometric functions from the specification. * Rakudo has a new signature binder which makes calling routines and operators much faster, and allows binding of positional arguments by name. * Rakudo has improved signature introspection, better errors relating to signatures and signature literals are now supported. * Rakudo now supports accessing outer lexical variables from classes and packages. * Some new variants of the series operator are now implemented. * When configuring Rakudo with --gen-parrot, the --optimize flag is now passed to Parrot's Configure.pl The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#23) is scheduled for November 19, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2009-11000644 000765 000024 00000006034 12573545401 020424 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #23 ("Lisbon") On behalf of the Rakudo development team, I'm pleased to announce the November 2009 development release of Rakudo Perl #23 "Lisbon". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the November 2009 release is available from http://github.com/rakudo/rakudo/downloads Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we recommend building Rakudo from the latest source, available from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo. Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. The November 2009 release is code named "Lisbon" for Lisbon.pm, who did a marvellous job arranging this year's YAPC::EU. Shortly after the October 2009 (#22) release, the Rakudo team began a new branch of Rakudo development ("ng") that refactors the grammar to much more closely align with STD.pm as well as update some core features that have been difficult to achieve in the master branch [1, 2]. Most of our effort for the past month has been in this new branch, but as of the release date the new version had not sufficiently progressed to be the release copy. We expect to have the new version in place in the December 2009 release. This release of Rakudo requires Parrot 1.8.0. One must still perform "make install" in the Rakudo directory before the "perl6" executable will run anywhere other than the Rakudo build directory. For the latest information on building and using Rakudo Perl, see the readme file section titled "Building and invoking Rakudo". Some of the specific changes and improvements occuring with this release include: * Rakudo is now passing 32,753 spectests, an increase of 171 passing tests since the October 2009 release. With this release Rakudo is now passing 85.5% of the available spectest suite. * As mentioned above, most development effort for Rakudo in November has taken place in the "ng" branch, and will likely be reflected in the December 2009 release. * Rakudo now supports unpacking of arrays, hashes and objects in signatures * Rakudo has been updated to use Parrot's new internal calling conventions, resulting in a slight performance increase. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#24) is scheduled for December 17, 2009. A list of the other planned release dates and codenames for 2009 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://use.perl.org/~pmichaud/journal/39779 [2] http://use.perl.org/~pmichaud/journal/39874 rakudo-2015.11/docs/announce/2009-12000644 000765 000024 00000007306 12573545401 020430 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #24 ("Seoul") On behalf of the Rakudo development team, I'm pleased to announce the December 2009 development release of Rakudo Perl #24 "Seoul". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the December 2009 release is available from http://github.com/rakudo/rakudo/downloads Due to the continued rapid pace of Rakudo development and the frequent addition of new Perl 6 features and bugfixes, we recommend building Rakudo from the latest source, available from the main repository at github. More details are available at http://rakudo.org/how-to-get-rakudo. Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. The December 2009 release is code named "Seoul" for Seoul.pm, who hosted Jonathan so well recently, and because they have a cake duck. Shortly after the October 2009 (#22) release, the Rakudo team began a new branch of Rakudo development ("ng") that refactors the grammar to much more closely align with STD.pm as well as update some core features that have been difficult to achieve in the master branch [1, 2]. Most of our effort for the past month has been in this new branch, but as of the release date the new version had not sufficiently progressed to be the release copy. We expect to have the new version in place in the January 2010 release, but may elect to have an interim release from the new branch before then. This release of Rakudo requires Parrot 1.9.0. One must still perform "make install" in the Rakudo directory before the "perl6" executable will run anywhere other than the Rakudo build directory. For the latest information on building and using Rakudo Perl, see the readme file section titled "Building and invoking Rakudo". Some of the specific changes and improvements occuring with this release include: * Rakudo is now passing 32,192 spectests, a "decrease" of 561 passing tests since the November 2009 release. We pass fewer tests now because specification changes caused many obsolete (but passing) tests to be removed from the suite -- from 38,318 in November to 37,376 now. The percentage of passing tests has increased, from 85.5% in November to 86.1% today. * More improvements to the Rat type and related math functions to remain aligned with the specification. The Perl 6 language specification is still in flux. Please take note of the following changes, which might affect your existing programs. In the next release of Rakudo, the deprecated features will likely be gone. * The root of the object hierarchy has been changed from 'Object' to 'Mu'. The type 'Object' goes away. * The term 'undef' is gone. You can replace it with other constructs, depending on context: - 'Nil' is undefined in item context, and the empty list in list context - 'Mu' is the most general undefined value which does not flatten in list context - as a smart matching target, you can replace '$obj ~~ undef' by '$obj ~~ *.notdef' The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#25) is scheduled for January 21, 2010. A list of the other planned release dates and codenames for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://use.perl.org/~pmichaud/journal/39779 [2] http://use.perl.org/~pmichaud/journal/39874 rakudo-2015.11/docs/announce/2010-01000644 000765 000024 00000010007 12573545401 020406 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #25 ("Minneapolis") On behalf of the Rakudo development team, I'm pleased to announce the January 2010 development release of Rakudo Perl #25 "Minneapolis". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the January 2010 release is available from http://github.com/rakudo/rakudo/downloads . Rakudo Perl follows a monthly release cycle, with each release code named after a Perl Mongers group. The January 2010 release is code named "Minneapolis" for Minneapolis.pm, hosts of the annual Frozen Perl Workshop [1]. In 2009 the Frozen Perl Workshop featured a one-day hackathon for Perl 6 and Rakudo development, which ultimately informed the design and implementation of the current build system. (The 2010 Frozen Perl Workshop will be on February 6, 2010, for those interested in attending.) Shortly after the October 2009 (#22) release, the Rakudo team began a new branch of Rakudo development ("ng") that refactors the grammar to much more closely align with STD.pm as well as update some core features that have been difficult to achieve in the master branch [2, 3]. We had planned for this release to be created from the new branch, but holiday vacations and other factors conspired against us. This is absolutely the final release from the old development branch; we expect to make the new branch the official "master" branch shortly after this release. This release of Rakudo requires Parrot 2.0.0. One must still perform "make install" in the Rakudo directory before the "perl6" executable will run anywhere other than the Rakudo build directory. For the latest information on building and using Rakudo Perl, see the README file section titled "Building and invoking Rakudo". Some of the specific changes and improvements occuring with this release include: * Rakudo is now passing 31,957 spectests, or 85.7% of the available test suite. This is roughly the same level as the December 2009 release (because most effort has taken place in the "ng" branch as described above). * Rakudo's calling conventions have been updated to match changes in Parrot 2.0.0's calling and context structures. The Perl 6 language specification is still in flux. Please take note of the following changes, which might affect your existing programs. In the next release of Rakudo, the deprecated features will likely be gone. * The root of the object hierarchy has been changed from 'Object' to 'Mu'. The type 'Object' goes away. * The term 'undef' is gone. You can replace it with other constructs, depending on context: - 'Nil' is undefined in item context, and the empty list in list context - 'Mu' is the most general undefined value which does not flatten in list context - as a smart matching target, you can replace '$obj ~~ undef' by '$obj ~~ *.notdef' * Builtin classes will derive from 'Cool' (which itself derives from 'Any'). Most of the builtin methods on these classes will be defined in the 'Cool' class instead of 'Any'. See Synopsis 2 for more details. * Starting with the next release, we will likely switch to using "YYYY.MM" instead of "YYYY-MM" (dot instead of hyphen) as release identifiers. This is intended to simplify building and packaging for other distribution systems. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#26) is scheduled for February 18, 2010. A list of the other planned release dates and codenames for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://www.frozen-perl.org/ [2] http://use.perl.org/~pmichaud/journal/39779 [3] http://use.perl.org/~pmichaud/journal/39874 rakudo-2015.11/docs/announce/2010.02000644 000765 000024 00000010160 12573545401 020410 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #26 ("Amsterdam") On behalf of the Rakudo development team, I'm pleased to announce the February 2010 development release of Rakudo Perl #26 "Amsterdam". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the February 2010 release is available from http://github.com/rakudo/rakudo/downloads . Rakudo Perl follows a monthly release cycle, with each release named after a Perl Mongers group. The February 2010 release is code named "Amsterdam" for the largest chapter of the Dutch Perl Mongers. Perl development enjoys considerable support from the Netherlands, with donations from NLNet, and hosting of the feather machines and several important Perl 6 web domains and sites. This release is the first release based on the new branch of Rakudo development begun in October 2009. The branch refactors the grammar, object metamodel, and a number of other key features to improve compatibility with the Perl 6 specification and give us a more solid foundation to build on. Indeed, in many ways the development of this new branch has driven important changes to the specification in the areas of lists, iterators, slices, and much more. However, this release contains a number of significant regressions from previous compiler releases. We expect to have full functionality restored in this branch in the next couple of weeks. For those looking to explore a wide variety of Perl 6 features or who have applications developed using previous releases of Rakudo, you may wish to continue to use the January 2010 (#25, "Minneapolis") release. This release of Rakudo requires Parrot 2.1.0. One must still perform "make install" in the Rakudo directory before the "perl6" executable will run anywhere other than the Rakudo build directory. For the latest information on building and using Rakudo Perl, see the README file section titled "Building and invoking Rakudo". Some of the specific changes and improvements occuring with this release include: * Now using nqp-rx for parsing and actions * Grammar is much closer to STD in many aspects, and makes use of protoregexes * Closures and lexical/contextual variable declarations in regexes work * Laziness is implemented * All class and role construction is handled through the meta-model The Perl 6 language specification is still in flux. Please take note of the following changes, which might affect your existing programs. In the next release of Rakudo, the deprecated features will likely be gone. * The root of the object hierarchy has been changed from 'Object' to 'Mu'. The type 'Object' goes away. * The term 'undef' is gone. You can replace it with other constructs, depending on context: - 'Nil' is undefined in item context, and the empty list in list context - 'Mu' is the most general undefined value which does not flatten in list context - as a smart matching target, you can replace '$obj ~~ undef' by '$obj ~~ *.notdef' * Builtin classes will derive from 'Cool' (which itself derives from 'Any'). Most of the builtin methods on these classes will be defined in the 'Cool' class instead of 'Any'. See Synopsis 2 for more details. * Starting with the this release, release identifiers are given as "YYYY.MM" instead of "YYYY-MM" (dot instead of hyphen). This is intended to simplify building and packaging for other distribution systems. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#27) is scheduled for March 18, 2010. A list of the other planned release dates and codenames for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://www.frozen-perl.org/ [2] http://use.perl.org/~pmichaud/journal/39779 [3] http://use.perl.org/~pmichaud/journal/39874 rakudo-2015.11/docs/announce/2010.03000644 000765 000024 00000005362 12573545401 020421 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #27 ("Copenhagen") On behalf of the Rakudo development team, I'm pleased to announce the March 2010 development release of Rakudo Perl #27 "Copenhagen". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the March 2010 release is available from http://github.com/rakudo/rakudo/downloads . Rakudo Perl follows a monthly release cycle, with each release named after a Perl Mongers group. The March 2010 release is code named "Copenhagen" for Copenhagen.pm, hosts of the Perl 6 Copenhagen Hackathon [1], which took place in connection with the Open Source Days Conference. The main goal of the hackathon was to raise some awareness around Perl 6, and to give everyone a chance to get their hands-on with Perl 6. The Copenhagen hackathon helped nail down a number of issues regarding module loading. During these days we also saw a heightened activity on the channel, in the Perl 6 and Rakudo repositories, and in the number of passing tests. All this was contributed by people both on location and elsewhere. The RT queue peaked at 725 new/open tickets, and then started on a downward trend. Apart from the great steps forward in productivity, it was the first time some of the core Perl 6 contributors had a chance to meet. Some of the specific changes and improvements occuring with this release include: * Numerous updates to trigonometric functions and the Rat class * Basic s/// and s[...] = '...' implemented * use improved and need/import implemented, with some basic support for versioned modules and lexical importation * Grammars work again and now include support for regexes taking parameters and proto-regexes * Series operator now has basic support for the current Spec. * User defined operators working again * Support, though with caveats, for !, R, X and Z meta-operators * Performance improvements for invocation and hash creation * Various parsing bugs fixed * Variables initialized to Any by default now, not Mu * ROADMAP updates For a more detailed list of changes see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#28) is scheduled for April 22, 2010. A list of the other planned release dates and codenames for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://conferences.yapceurope.org/hack2010dk/ rakudo-2015.11/docs/announce/2010.04000644 000765 000024 00000004357 12573545401 020425 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #28 ("Moscow") On behalf of the Rakudo development team, I'm pleased to announce the March 2010 development release of Rakudo Perl #28 "Moscow". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the April 2010 release is available from http://github.com/rakudo/rakudo/downloads . Rakudo Perl follows a monthly release cycle, with each release named after a Perl Mongers group. The April 2010 release is code named "Moscow" in recognition of Москва.пм and their invitation of Jonathan Worthington, one of our core develepors, to speak at the Russian Internet Technologies 2010 [1] conference. Some of the specific changes and improvements occuring with this release include: * Expressions that begin with a variable and end with a circumfix now properly interpolate into double-quoted strings, like "@array.sort()" or "%hash". * Item assignment now has tighter precdence than list assignment, so both 'my @a = 1, 2, 3' and '$a = 1, $b = 2' magically work. * Most of the DateTime built-in type has been backported from the "alpha" branch, and is now accompanied by a Date type for date-only calculations. * Many obsolete uses of Perl 5 constructs are now caught and give helpful error messages. * As always, many additional small features and bug fixes make working with Rakudo more pleasant. * Rakudo now passes 30,931 spectests. We estimate that there are about 39,000 tests in the test suite, so Rakudo passes about 79% of all tests. For a more detailed list of changes see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible. If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#29) is scheduled for May 20, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1]: http://ritconf.ru/ rakudo-2015.11/docs/announce/2010.05000644 000765 000024 00000005005 12573545401 020415 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #29 ("Erlangen") On behalf of the Rakudo development team, I'm pleased to announce the May 2010 development release of Rakudo Perl #29 "Erlangen". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see http://www.parrot.org). The tarball for the May 2010 release is available from http://github.com/rakudo/rakudo/downloads . Rakudo Perl follows a monthly release cycle, with each release named after a Perl Mongers group. The May 2010 release is code named "Erlangen" in recognition of Erlangen.pm and the Perl 6 talk that Moritz Lenz, one of our core developers, gave this month. Some of the specific changes and improvements occurring with this release include: * Lexical classes and roles were implemented. Additionally, anonymous classes -- which were never quite right in alpha -- are now implemented more correctly, and anonymous roles are also supported. * Basic support for named enumerations of the form 'enum Weekday ' has been restored. * First cut of use Foo:from and eval('foo', :lang); needs Blizkost[1] to be installed to work. * Numeric / Real roles much closer to the spec now. * As always, many additional small features and bug fixes make working with Rakudo more pleasant. * Rakudo now passes 32,347 spectests. We estimate that there are about 39,500 tests in the test suite, so Rakudo passes about 82% of all tests. For a more detailed list of changes see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Solomon Foster, Moritz Lenz, Jonathan Worthington, Martin Berends, chromatic, Carl Masak, snarkyboojum, Stefan O'Rear, Reini Urban, Jonathan Scott Duff, takadonet, Christoph Otto, isBEKaml, ash_, bubaflub, Jimmy Zhuo, Peter Lobsinger and Patrick Abi Salloum If you would like to contribute, see http://rakudo.org/how-to-help , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#30) is scheduled for June 17, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://github.com/jnthn/blizkostrakudo-2015.11/docs/announce/2010.06000644 000765 000024 00000005674 12573545401 020432 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 development release #30 ("Kiev") On behalf of the Rakudo development team, I'm pleased to announce the June 2010 development release of Rakudo Perl #30 "Kiev". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the June 2010 release is available from . Rakudo Perl follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after the Perl Mongers from the beautiful Ukrainian capital, Kiev. They recently helped organize and participated in the Perl Mova + YAPC::Russia conference, the хакмит (hackathon) of which was a particular success for Rakudo. All those who joined the Rakudo hacking - from Kiev and further afield - contributed spec tests as well as patches to Rakudo, allowing various RT tickets to be closed, and making this month's release better. Дякую! Some of the specific changes and improvements occurring with this release include: * Rakudo now uses immutable iterators internally, and generally hides their existence from programmers. Many more things are now evaluated lazily. * Backtraces no longer report routines from Parrot internals. This used to be the case in the Rakudo alpha branch as well, but this time they are also very pleasant to look at. * Match objects now act like real hashes and arrays. * Regexes can now interpolate variables. * Hash and array slicing has been improved. * The REPL shell now prints results, even when not explicitly asked to print them, thus respecting the "P" part of "REPL". * Rakudo now passes 33,378 spectests. We estimate that there are about 39,900 tests in the test suite, so Rakudo passes about 83% of all tests. For a more detailed list of changes see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Patrick R. Michaud, Moritz Lenz, Jonathan Worthington, Solomon Foster, Patrick Abi Salloum, Carl Mäsak, Martin Berends, Will "Coke" Coleda, Vyacheslav Matjukhin, snarkyboojum, sorear, smashz, Jimmy Zhuo, Jonathan "Duke" Leto, Maxim Yemelyanov, Stéphane "cognominal" Payrard, Gerd Pokorra, Bruce Keeler, Ævar Arnfjörð Bjarmason, Shrivatsan, Hongwen Qiu, quester, Alexey Grebenschikov, Timothy Totten If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#31) is scheduled for July 22, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2010.07000644 000765 000024 00000005570 12573545401 020426 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #31 ("Atlanta") On behalf of the Rakudo development team, I'm happy to announce the July 2010 development release of Rakudo Perl #31 "Atlanta". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the July 2010 release is available from . Please note: This is not the Rakudo Star release, which is scheduled for July 29, 2010 [1]. The Star release will include the compiler, an installer, modules, a book (PDF), and more. The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The July 2010 release is code named "Atlanta" in recognition of Atlanta.pm and their Perl 5 Phalanx project [2], which they selected for its benefits to Perl 6. Some of the specific changes and improvements occurring with this release include: * Rakudo now properly constructs closures in most instances. * Undefined objects can now autovivify into arrays or hashes when subscripted with .[ ] or .{ } . * Arrays can now handle infinite ranges. * Generic, multi-level Whatever-currying now works, e.g. (1, 1, *+* ... *). * The REPL shell now remembers lexical declarations in susbsequent lines. * The open() subroutine now returns a Failure instead of throwing a fatal exception. * Rakudo now provides $*ARGFILES for reading from files specified on the command line. * Added $*PERL, moved %*VM to $*VM. * Simple binding operators := and ::= now work. * Simple feed operators <== and ==> now work. For a more detailed list of changes see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Patrick R. Michaud, Jonathan Worthington, Moritz Lenz, Solomon Foster, Carl Masak, Bruce Gray, Martin Berends, chromatic, Will "Coke" Coleda, Matthew (lue), Timothy Totten, maard, Kodi Arfer, TimToady, Stephen Weeks, Patrick Abi Salloum, snarkyboojum, Radu Stoica, Vyacheslav Matjukhin, Andrew Whitworth, cognominal, Tyler Curtis, Alex Kapranoff, Ingy döt Net, Lars Dɪᴇᴄᴋᴏᴡ 迪拉斯, mathw, lue, Вячеслав Матюхин If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#32) is scheduled for August 19, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://rakudo.org/node/73 [2] http://code.google.com/p/atlanta-pm-code/ rakudo-2015.11/docs/announce/2010.08000644 000765 000024 00000005413 12573545401 020423 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #32 ("Pisa") On behalf of the Rakudo development team, I'm happy to announce the August 2010 release of Rakudo Perl #32 "Pisa". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the August 2010 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The August 2010 release is code named "Pisa" in recognition of its excellent work in organizing YAPC::EU 2010, "The Renaissance of Perl" [1,2]. Many Rakudo developers presented at the conference, and it was an excellent location for a hackathon and planning the next phases of Rakudo development. Some of the specific changes and improvements occurring with this release include: * Due to a specification change, Nil is now undefined, and no longer simply an empty Parcel. * Many modifiers are now recognized on the outside of regexes and substitutions, for example s:g:samecase/abc/defg/ * Improvements to the performance of integer operations * Initial implementations of .pack and .unpack methods for the Buf class * Smartmatching against True or False is now an error. Most people who did this really wanted to look at the return value of .so instead. For a more detailed list of changes see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Patrick R. Michaud, Solomon Foster, Will "Coke" Coleda, Carl Mäsak, Jonathan Worthington, Bruce Gray, Patrick Abi Salloum, tylercurtis, Kyle Hasselbacher, Tadeusz Sośnierz, Jonathan Scott Duff, Christopher J. Madsen, Kodi Arfer, Reini Urban, TimToady, felliott, Matt Kraai, Jan Ingvoldstad, szabgab, madsen, Andy Lester, cosimo, Fitz Elliott If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#33) is scheduled for September 23, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! [1] http://www.perl.it/ [2] http://conferences.yapceurope.org/ye2010/ rakudo-2015.11/docs/announce/2010.09000644 000765 000024 00000005407 12573545401 020427 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #33 ("Milan") On behalf of the Rakudo development team, I'm happy to announce the August 2010 release of Rakudo Perl #33 "Milan". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the September 2010 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The September 2010 release is code named "Milan", because the release manager happens to like the name :-) Some of the specific changes and improvements occurring with this release include: * The specification for temporal objects (DateTime, Date, Instant and Duration) is now completely implemented in Rakudo * Several performance improvements were implemented, most notably in slurp() and reverse() functions * The series operator has been refactored, and updated to the current specification * Enumeration objects now conform much closer to the current specification * 'now' and 'time' are now terms (and not functions anymore). This means you can now write 'time - 1' and do what you mean, but 'time()' does not work anymore For a more detailed list of changes see "docs/ChangeLog". Deprecation notice: * Currently True and False evaluate as '1' and '0' in string context. The specification has changed, and in the next release they will evaluate to 'Bool::True' and 'Bool::False' in string context. To get the old behaviour, use ~+True or ~+False. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Patrick R. Michaud, Carl Masak, Patrick Abi Salloum, Solomon Foster, Kodi Arfer, chromatic, Kyle Hasselbacher, Bruce Gray, Martin Berends, Stephane Payrard, Tyler Curtis, Shlomi Fish, Nick Wellnhofer, Nuno Carvalho, Tadeusz Sośnierz, TiMBuS, NotFound, mathw If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#34) is scheduled for October 21, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2010.10000644 000765 000024 00000004470 12573545401 020416 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #34 ("Paris") On behalf of the Rakudo development team, I'm happy to announce the October 2010 release of Rakudo Perl #34 "Paris". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the October 2010 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The October 2010 release is code named "Paris", because the of the Perl love at the Open Source Developers Conference held in Paris, France earlier in the month. Some of the specific changes and improvements occurring with this release include: * we now have a simple version of require * the local timezone is available in $*TZ * samespace versions of m// and s/// were implemented as ms// and ss/// respectively. * Str.flip is now 100 times faster than it used to be * the subroutine version of Str.comb now exists * Hyperoperators can now be applied to infix:<+=> and friends. * improved diagnostic messages For a more detailed list of changes see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Kodi Arfer, Patrick R. Michaud, Bruce Gray, Carl Masak, Ronald Schmidt, Jonathan Worthington, TimToady, TimTom, PhatEddy, Patrick Abi Salloum, and your humble release manager Jonathan Scott Duff. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#35) is scheduled for November 18, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2010.11000644 000765 000024 00000004144 12573545401 020415 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #35 ("Melbourne") On behalf of the Rakudo development team, I'm happy to announce the November 2010 release of Rakudo Perl #35 "Melbourne". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the November 2010 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The November 2010 release is code named "Melbourne", PM group of Damian Conway, long-time advocate/explicator of and contributor to Perl 6. Some of the specific changes and improvements occurring with this release include: * qw// is now implemented * .trans is now 5 times faster * indexing is now possible with both ranges and Whatever offsets together: @a[0 .. *-2] For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Solomon Foster, Kodi Arfer, Tadeusz Sośnierz, Nick Wellnhofer, Jonathan Scott Duff, Bruce Gray, Jonathan Worthington, Patrick R. Michaud, mikehh, flussence, Jan Ingvoldstad, and your humble release manager Carl Mäsak. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#36) is scheduled for December 23, 2010. A list of the other planned release dates and code names for 2010 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2010.12000644 000765 000024 00000004006 12573545401 020413 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #36 ("New York") On behalf of the Rakudo development team, I'm happy to announce the December 2010 release of Rakudo Perl #36 "New York". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the December 2010 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The December 2010 release is code named "New York" the first PM group, created by brian d foy, in tribute to Perl's 23rd anniversary, which was celebrated on the 18th of this month. Some of the specific changes and improvements occurring with this release include: * new .trans algorithm * configuration improvements * several bug fixes For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Carl Masak, Solomon Foster, Kodi Arfer, Fernando Brito, Tomoki Aonuma, Nick Wellnhofer, Patrick R. Michaud, Abi Salloum, frettled, smashz and Jonathan Scott Duff. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#37) is scheduled for January 20, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2011.01000644 000765 000024 00000004134 12573545401 020414 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #37 ("BristolBath") On behalf of the Rakudo development team, I'm happy to announce the January 2011 release of Rakudo Perl #37 "BristolBath". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the January 2011 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The December 2010 release is code named after Bristol & Bath Perl Mongers group. Some of the specific changes and improvements occurring with this release include: * faster subroutine calls (type cache) * implemented 'handles Rolename' trait * 'use Devel::Trace' debugging pragma * improved parsing of keyword boundaries * faster .comb For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Kodi Arfer, smashz, Jonathan Worthington, Solomon Foster, Tadeusz Sośnierz, Kyle Hasselbacher, Patrick R. Michaud, Jonathan Scott Duff, Fitz Elliott, Adrian White, Christoph Otto, Stefan O'Rear, Michael H. Hind, Vasily Chekalkin and Hongwen Qiu. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#38) is scheduled for February 17, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2011.02000644 000765 000024 00000004030 12573545401 020410 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #38 ("Toulouse") On behalf of the Rakudo development team, I'm happy to announce the February 2011 release of Rakudo Perl #38 "Toulouse". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the February 2011 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The February 2011 release is code named "Toulouse". Some of the specific changes and improvements occurring with this release include: * basic IPv6 support * new --ll-backtrace command line option for low level backtraces * the negation meta operator can now only be applied to operators where it makes sense. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Solomon Foster, Kodi Arfer, Tadeusz Sośnierz, Patrick R. Michaud, Carl Masak, Jonathan Scott Duff, Jonathan Worthington, Vasily Chekalkin, Will "Coke" Coleda, Michael Stapelberg, Arne Skjærholt, Fitz Elliott If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#39) is scheduled for March 17, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2011.03000644 000765 000024 00000003772 12573545401 020425 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #39 ("Orlando") On behalf of the Rakudo development team, I'm happy to announce the March 2011 release of Rakudo Perl #39 "Orlando". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the March 2011 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The March 2011 release is code named "Orlando". Some of the specific changes and improvements occurring with this release include: * an improved error message on type check failure in assignment * -n and -p command line options * complex conjugation support implemented For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Tadeusz Sośnierz, Carl Masak, Arne Skjærholt, William Orr, Kyle Hasselbacher, Jonathan Scott Duff, Dave Whipp, Jonathan Worthington, martin, Solomon Foster, JD Horelick, Jimmy Zhuo, Martin Berends, Patrick Abi Salloum, JimmyZ If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#40) is scheduled for April 21, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2011.04000644 000765 000024 00000004072 12573545401 020420 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #40 ("ZA") On behalf of the Rakudo development team, I'm happy to announce the April 2011 release of Rakudo Perl #40 "ZA". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the April 2011 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The April 2011 release is code named "ZA" after ZA.pm in Grahamstown, Eastern Cape, South Africa because the denizens of #perl6 have an unusual facination with zebras and ZA just happens to have a "Z" and, according to my meager research, there are indeed zebras in the area. :-) Some of the specific changes and improvements occurring with this release include: * implemented Str.indent * A new, much simpler API and implemention of IO::Socket::INET For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Tadeusz Sośnierz, Martin Berends, Andy Lester, Jonathan Scott Duff, flussence, Patrick Abi Salloum, Carl Masak, Jarrod If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#41) is scheduled for May 19, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2011.05000644 000765 000024 00000003576 12573545401 020431 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #41 ("Dahut") On behalf of the Rakudo development team, I'm happy to announce the May 2011 release of Rakudo Perl #41 "Dahut". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the May 2011 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The May 2011 release is code named "Dahut". Some of the specific changes and improvements occurring with this release include: * added a call counter for builtins in Perl 6-level subroutines * gcd (greatest common divisor) and lcm (largest common multiple) operators * implemented Int.base For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Patrick R. Michaud, Moritz Lenz, Jonathan Scott Duff, Tadeusz Sośnierz, Carl Masak, Solomon Foster, bacek If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#42) is scheduled for June 23, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2011.06000644 000765 000024 00000004577 12573545401 020434 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #42 ("Bruxelles") On behalf of the Rakudo development team, I'm happy to announce the June 2011 release of Rakudo Perl #42 "Bruxelles". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the June 2011 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The June 2011 release is code named "Bruxelles". DON'T PANIC: Browsing the change log below, it might appear as though not much Rakudo development is taking place. Nearly all of the development activity is now occurring in the "nom" branch of the Rakudo repository (over 500 commits since the 2011.05 release). This new branch will shortly become the mainline branch from which monthly releases are made, and already contains many important bugfixes and performance improvements. Some of the specific changes and improvements occurring in the master branch with this release include: * Fixed a bug with &infix:<=> when used in multiple assignments to aggregate elements. * Improved parrot register handling for more efficient code. * Added take-rw and return-rw functions. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Patrick R. Michaud, Moritz Lenz, Martin Berends, Tadeusz Sośnierz, JD Horelick, and others. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#43) is scheduled for July 21, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun and don't forget your towel! rakudo-2015.11/docs/announce/2011.07000644 000765 000024 00000005264 12573545401 020427 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #43 ("Beijing") On behalf of the Rakudo development team, I'm happy to announce the July 2011 release of Rakudo Perl #43 "Beijing". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for the July 2011 release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The July 2011 release is code named "Beijing" after the host of the Beijing Perl Workshop 2011, which featured several Perl 6 related talks. This will be the last compiler release made from the current "master" branch of Rakudo. For the past several months, Rakudo compiler development has primarily occurred in the "nom" branch of the Rakudo repository (over 1200 commits since the 2011.05 release). Shortly after this release, the "nom" branch will become the new "master" branch and will be the source for future releases, including the 2011.08 release. We expect there will be several releases in the near future -- watch http://rakudo.org/ for details. Some of the specific changes and improvements occurring in the master branch with this release include: * Fix bug in exponentation of negative numbers * Fix build on systems with little RAM For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Patrick R. Michaud, atrodo, Solomon Foster, bacek and others. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. Rakudo has traditionally released two days after each Parrot monthly release. Because the new version of the compiler has additional dependencies beyond Parrot, starting in August 2011 we will make releases sometime in the week following each monthly Parrot release. (Parrot releases occur on the third Tuesday of each month.) Thus the next regular release of Rakudo will occur sometime before August 23, 2011. We also expect to have additional "pre-release" versions of Rakudo and Rakudo Star prior to that date. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. rakudo-2015.11/docs/announce/2011.09000644 000765 000024 00000007621 12573545401 020430 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #44 ("Riga") On behalf of the Rakudo development team, I'm happy to announce the September 2011 release of Rakudo Perl #44 "Riga". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The September 2011 release is code named after the host city of the YAPC::EU 2011 conference, which included a very successful Perl 6 track and hackathon. This is the first compiler release from the latest development branch of Rakudo. It brings many exciting improvements, but also some regressions, which we are working on. If your primary interest is that your existing code running on Rakudo Perl continues to work, we suggest sticking with the Rakudo Star distribution release for a little longer. If instead you want to play with the latest in Rakudo development - including meta-programming and performance improvements - try this release. Some of the specific changes and improvements occurring with this release include: * numerous speedups * Int, Num and Str are now far more lightweight * int/num as attributes are stored compactly in the object body * meta objects are now much easier to modify * a Pod parser capable of attaching documentation to objects * --doc command line option producing formatted documentation * much more robust handling of infinite list * basic LoL (List of Lists) support * :U and :D type modifiers * improved handling of BEGIN phasers * protos and multis now conform to the new spec * improved enum support * basic 'constant' declarator * .WHAT and friends as macros * 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) * many bug fixes in parametric roles * 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 * a new regex engine We briefly regress on a few features since the previous release. Most notably, new regex engine has not implemented proto regexes yet, and only integer-based enums are available. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Patrick R. Michaud, Tadeusz Sośnierz, Will "Coke" Coleda, Solomon Foster, Kodi Arfer, Carl Mäsak, Martin Berends, kboga, Jonathan Scott Duff, Michael Schröder, JD Horelick, TimToady, Arne Skjærholt, Kyle Hasselbacher, flussence, Dave Whipp, William Orr, Jimmy Zhuo, Andy Lester, Patrick Abi Salloum, Fitz Elliott, snarkyboojum, Ruslan Zakirov, Vasily Chekalkin, kristof, Stefan O'Rear, Geoff Broadwell, Martin Kjeldsen, supernovus, Timothy Totten, Felix Herrmann, Jarrod, mikehh, Michael Stapelberg, baest, Erik Johansen, bbkr If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#45) is scheduled for October 20, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur two days after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have fun! rakudo-2015.11/docs/announce/2011.10000644 000765 000024 00000007017 12573545401 020417 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #45 ("Houston") On behalf of the Rakudo development team, I'm happy to announce the October 2011 release of Rakudo Perl #45 "Houston". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The October 2011 release is code named after the Houston Perl Mongers because Houston is a large city in Texas and because Perl 6 could always use more features from Texas. Oh ... and Houston also hosted YAPC::NA 2007 and had a nice Perl 6 hackathon. :-) This compiler release is from the latest development branch of Rakudo. It brings many exciting improvements, but also some regressions, which we are working on. If your primary interest is that your existing code running on Rakudo Perl continues to work, we suggest sticking with the Rakudo Star distribution release for a little longer. If instead you want to play with the latest in Rakudo development - including meta- programming and performance improvements - try this release. Some of the specific changes and improvements occurring with this release include: * Optimizations tuneable from the command line * native types on various operators * Fix start up error when $HOME environment variable isn't set * Fix C3 MRO bug * Start at implementing global matching (m:g//) * Various performance improvements We are still regressed on a few features just as in the previous release. These regressions should be rectified in coming releases. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Will "Coke" Coleda, Tadeusz Sośnierz, Patrick R. Michaud, Jonathan Scott Duff, Carl Masak, Geoffrey Broadwell, mls, snarkyboojum, gfldex, TimToady, TiMBuS, JimmyZ If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#46) is scheduled for November 17, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. As always ... Have fun! [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enchance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2011.11000644 000765 000024 00000007205 12573545401 020417 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #46 ("London") On behalf of the Rakudo development team, I'm happy to announce the November 2011 release of Rakudo Perl #46 "London". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The November 2011 release is code named after the London Perl Mongers, organizers of many London Perl Workshops, including the 2011 edition that took place this month. Over 200 people showed up for this great event, which had some Perl 6 talks amongst the schedule. This compiler release is from the latest development branch of Rakudo. It brings many exciting improvements, but also some regressions compared to the compiler release shipped with the latest Rakudo Star distribution. If your primary interest is that your existing code running on Rakudo Perl continues to work, we suggest sticking with the Rakudo Star distribution release for a little longer; we are aiming to issue a Rakudo Star based on this development branch in December. If instead you want to play with the latest in Rakudo development - including meta-programming and performance improvements - try this release. Some of the specific changes and improvements occurring with this release include: * Big integer support * Basic protoregex support with NFA-driven LTM for some declarative constructs * CATCH blocks are now much closer to spec, and thus much more useful * Improved support for MAIN argument parsing We are still regressed on a few features just as in the previous release. These regressions should be rectified in coming releases. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Will "Coke" Coleda, Tadeusz Sośnierz, Geoffrey Broadwell, Solomon Foster, Jonathan Scott Duff, Michael Schroeder, Carl Masak, Geoff Broadwell, not_gerd and coto If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#47) is scheduled for December 22, 2011. A list of the other planned release dates and code names for 2011 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have a great deal of fun! [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enchance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2011.12000644 000765 000024 00000005742 12573545401 020424 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #47 ("Columbus") On behalf of the Rakudo development team, I'm happy to announce the November 2011 release of Rakudo Perl #47 "Columbus". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The December 2011 release is code named after the Columbus Perl Mongers, organizers of YAPC::NA 2010, which featured a Perl 6 track and hackathon. Some of the specific changes and improvements occurring with this release include: * Many regex improvements, including escapes in character classes look-around assertions and many bug fixes * Several performance improvements * Defining new operators, flip flop operators, and the Proxy class are now supported We are still regressed on a few features compared to the 2011.07 release of Rakudo, the most notable of which is autovivification. These regressions should be rectified in coming releases. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Will "Coke" Coleda, Michael Schroeder, Tadeusz Sośnierz, Solomon Foster, Zohar Kelrich, diakopter, JimmyZ, Jonathan Scott Duff, Geoffrey Broadwell, Woodi If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#48) is scheduled for January 19, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have a great deal of fun! [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.01000644 000765 000024 00000005556 12573545401 020426 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #48 ("Toronto") On behalf of the Rakudo development team, I'm happy to announce the January 2012 release of Rakudo Perl #48 "Toronto". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The January 2012 release is code named after the Toronto Perl Mongers, organizers of YAPC::NA 2005, which featured a Perl 6 hackathon. Some of the specific changes and improvements occurring with this release include: * regex backtracking into subrules and captures now works * -c (compilation check) command line option works again * better parameter introspection * many bugfixes We are still regressed on a few features compared to the 2011.07 release of Rakudo, the most notable of which is autovivification. These regressions should be rectified in coming releases. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Kris Shannon, Tadeusz Sośnierz, kboga, Carl Masak, Bruce Gray, Solomon Foster, Geoffrey Broadwell, not_gerd, wollmers. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#49) is scheduled for February 23, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. Have a great deal of fun! [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.02000644 000765 000024 00000005740 12573545401 020422 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #49 ("SPb") On behalf of the Rakudo development team, I'm happy to announce the February 2012 release of Rakudo Perl #49 "SPb". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The February 2012 release is code named after the Saint Petersburg Perl Mongers, because Saint Petersburg as a city has provided unmatched inspiration and clarity to at least two Rakudo programmers. Some of the specific changes and improvements occurring with this release include: * Regex syntax: and * &rename and © functions * LHS of infix: now thunks as per spec * Improved backtraces * Rat arithmetic falling back to Num when needed; FatRat * Object hashes * Int($x)-style coercions We are still regressed on a few features compared to the 2011.07 release of Rakudo, the most notable of which is autovivification. These regressions should be rectified in coming releases. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Jonathan Worthington, Carl Masak, Tadeusz Sośnierz, kboga, Will "Coke" Coleda, TimToady, lumi, not_gerd, PerlJam, not_gerd. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#50) is scheduled for March 22, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. May a great deal of fun befall you! [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.03000644 000765 000024 00000006462 12573545401 020425 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #50 ("Argentina") On behalf of the Rakudo development team, I'm happy to announce the March 2012 release of Rakudo Perl #50 "Argentina". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The March 2012 release is code named after Argentina, because that's where one of our core contributors went to relax this month after adding some significant Perl 6 features to Rakudo. Some of the specific changes and improvements occurring with this release include: * greatly reduced startup time * significantly reduced memory usage during compilation of modules and of Rakudo itself. * implemented ENTER, LEAVE, KEEP, UNDO and START phasers * basic macros We are still regressed on a few features compared to the 2011.07 release of Rakudo, the most notable of which is autovivification. These regressions should be rectified in coming releases. Note that Rakudo now dies on 'our multi' declarations, which have poorly defined semantics. Please either declare an 'our proto' that re-dispatches to individual multis, or use exporting instead of package variables. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Carl Masak, Tadeusz Sośnierz, Siddhant Saraf, not_gerd, Filip Sergot, TimToady, Michael Schroeder, Patrick R. Michaud, sisar, lumi, Felix Herrmann, flussence, felher If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#51) is scheduled for April 19, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I admonish you to try the new release, to live life to its fullest, to cherish each day, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.04000644 000765 000024 00000006502 12573545401 020421 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #51 ("Brazos Valley") On behalf of the Rakudo development team, I'm happy to announce the April 2012 release of Rakudo Perl #51 "Brazos Valley". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The April 2012 release is code named after Brazos Valley, because they sponsored a Perl 6 Hackathon. Thanks! Some of the specific changes and improvements occurring with this release include: * Support for pseudo packages like MY, OUR, DYNAMIC * Support for indexing into packages like hashes, e.g. Foo::{'$x'} * Warnings now include line numbers * Assorted minor optimizations to compilation, Str methods and iteration * Now passing over 21,400 spec tests. We are still regressed on a few features compared to the 2011.07 release of Rakudo, the most notable of which is autovivification. These regressions will be rectified in coming releases. Two incompatible changes in this release are notable: * $?POD has been renamed to $?pod * 'defined' used to be a prefix operator, it is now an ordinary subroutine. Code like 'defined $a ?? $b !! $c' should be rewritten to use 'defined($a)' or '$a.defined' instead. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Jonathan Worthington, Patrick R. Michaud, Carl Mäsak, Timo Paulssen, Tadeusz Sośnierz, Felix Herrmann, spider-mario, benabik, timotimo, TimToady and Will "Coke" Coleda. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#52) is scheduled for May 17, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release. have fun, and let us know about your experience. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.04.1000644 000765 000024 00000005751 12573545401 020565 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release 2012.04.1 On behalf of the Rakudo development team, I'm happy to announce an out-of-schedule release of the Rakudo Perl 6 compiler. Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . This release is a point release in addition to the regular, monthly releases. It contains some of the results of the Perl 6 Patterns hackathon in Oslo. It is intended to be used as the basis for the next Rakudo Star release. The Rakudo developers would like to thank the organizers from Oslo.pm. Some of the specific changes and improvements occurring with this release include: * Support for autovivification. * More robust module precompilation * $.foo, @.foo and %.foo style calls now properly contextualize The 'lib' directory is not in the default search path for modules anymore. Module authors and users can adjust the PERL6LIB environment variable accordingly. For a more detailed list of changes, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Jonathan Worthington, Patrick R. Michaud, Carl Mäsak, Will "Coke" Coleda, Tadeusz Sośnierz, Marcus Ramberg, Timo Paulssen, Felix Herrmann, Geir Amdal, spider-mario, benabik, timotimo, TimToady If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#52) is scheduled for May 17, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release. have fun, and let us know about your experience. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.05000644 000765 000024 00000006101 12573545401 020415 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #52 ("MadMongers") On behalf of the Rakudo development team, I'm glad to announce the May 2012 release of Rakudo Perl #52 "MadMongers". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The May 2012 release is code named after MadMongers. This release includes a whole lot of changes since the last one, including: * -I and -M command-line options * support for non-Int enums * 'use' now accepts positional arguments and is able to import by tag name * 'import' now works * basic support for Version literals * %*ENV now propagates into subprocesses * basic implementation of pack and unpack ported from 'ng' branch * fff flip-flop operator is now implemented, ff has been improved * various new regex features and improvements Rakudo now also includes the lib.pm module. This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Jonathan Worthington, Patrick R. Michaud, Jonathan Scott Duff, Tadeusz Sośnierz, Carl Masak, Will "Coke" Coleda, Marcus Ramberg, kboga, TimToady, Kyle Hasselbacher, Geir Amdal, JimmyZ, benabik and gfldex. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#53) is scheduled for June 21, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release. Have fun, and let us know about your experience. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.06000644 000765 000024 00000005650 12573545401 020426 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #53 ("Strasbourg") On behalf of the Rakudo development team, I'm glad to announce the June 2012 release of Rakudo Perl #53 "Strasbourg". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The June 2012 release is code named after Strasbourg, the location of the French Perl Workshop 2012. This release includes a lot of changes since the last one, including: * Longest-Token Matching for | alternations in regexes * Stricter numification of strings (fails if the string does not represent a number) * 'require' now allows argument lists * Faster .map / list handling * Improvements to typed exceptions This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Contributors to Rakudo since the release on 2012-05-17: Moritz Lenz, Jonathan Worthington, Patrick R. Michaud, kboga, Jonathan Scott Duff, Tadeusz Sośnierz, Carl Masak, Geoffrey Broadwell, diakopter, Solomon Foster, JimmyZ, TimToady If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#54) is scheduled for July 19, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release. Have fun, and let us know about your experience. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.07000644 000765 000024 00000005754 12573545401 020434 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #54 ("Tallinn") On behalf of the Rakudo development team, I'm glad to announce the July 2012 release of Rakudo Perl #54 "Tallinn". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The July 2012 release is code-named after Tallinn, a fine old capital where jnthn and masak had much useful discussions about Perl 6 macro design last year. This release includes a lot of changes since the last one, including: - Built-in meta-objects (e.g. Metamodel::ClassHOW) now inherit from Any - &open now supports :enc/:encoding - Changed &dir to return IO::Path objects, not strings - Deprecated .bytes, .ucfirst, and .lcfirst on Str - recognize obosolete rand() and rand(N) forms at compile time - anonymous subset types 'subset :: of Int where { $_ > 0 }' This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Patrick R. Michaud, Moritz Lenz, Jonathan Worthington, Jonathan Scott Duff, Carl Mäsak, ronaldxs, Felix Herrmann, harmil, Gabor Szabo, sisar If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#55) is scheduled for August 23, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.08000644 000765 000024 00000007336 12573545401 020433 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #55 ("Frankfurt") On behalf of the Rakudo development team, I'm glad to announce the August 2012 release of Rakudo Perl #55 "Frankfurt". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The August 2012 release is code-named after Frankfurt.pm, the group that hosted this year's YAPC::Europe conference in Frankfurt am Mein. This release brings a massive amount of changes; some of them are outlined below: - Memory usage of build stage is reduced by 35% - 40% - Sigilless variables in signatures (prefixed by | or \) - Blocks that declare variables don't turn into hash constuctors anymore - Better error reporting for traits - --> ReturnType in signatures and prefix type constraints of routine return types are now honored - Circularities in module loading are now detected - Improvements in inliner, which allow it to inline a wider range of routines Some features have been deprecated: - Parameters preceeded by a | or \ may not have a sigil anymore. sub f(\$x) { say $x } must be changed to sub f(\x) { say x } Usage of \$x will unconditionally warn in 2012.09 and be removed in 2012.10 - IO::Path.dir (which returns the directory part of the path) has been renamed to IO::Path.directory. IO::Path.dir will be removed or re-purposed in 2012.09 - The LAZY statement prefix will be removed in 2012.09. It was a non-specced experiment and did not work out well. This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Arne Skjærholt, Geoffrey Broadwell, Will "Coke" Coleda, Tadeusz Sośnierz, Patrick R. Michaud, Felix Herrmann, Carl Mäsak, kboga, thou, Brian Gernhardt, Stefan O'Rear, GlitchMr, ChoHag, Larry Wall and lumi_ If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#56) is scheduled for September 20, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.09000644 000765 000024 00000006345 12573545401 020433 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #56 ("Perl") On behalf of the Rakudo development team, I'm thrilled to announce the September 2012 release of Rakudo Perl #56 "Perl". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The September 2012 release is code-named after Perl.pm, a group located in scenic Perl in Saarland, Germany, where an important meetup took place on August 16th-19th concerning the reunification of Perl 5 and Perl 6. This release brings changes; some of them are outlined below: - basic macro unquoting - basic support for m:P5/.../ regexes - support for indirect type names in routine and type declarations - support for "is export" traits on constants - Str.wordcase implemented - slightly faster compilation (thanks to switching NQP over to QAST) - tie-breaking with constraints now picks the first matching one rather than demanding they be mutually exclusive A possibly breaking change: - class Iterable does not inherit from class Cool anymore This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Carl Mäsak, Salve J. Nilsen, Patrick R. Michaud, Gerhard R, Tadeusz Sośnierz, Will "Coke" Coleda, Geoffrey Broadwell, diakopter, PerlJam, cognominal, Larry Wall If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#57) is scheduled for October 18, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.09.1000644 000765 000024 00000006241 12573545401 020565 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release 2012.09.1 On behalf of the Rakudo development team, I'm announcing an out-of-schedule release of the Rakudo Perl 6 compiler. Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . This release is a point release in addition to the regular, monthly releases. Rakudo 2012.09 (no .1) required Parrot 4.8.0, which was recently discovered to have some unfortunate regressions in standard input/output buffering for many environments. This interim release restores the compiler back to using Parrot 4.4.0 to allow more time to resolve I/O issues. This also means we revert to 2012.08's version of socket encoding (where sockets all assume utf8 encoding of data), but this reversion is considered of lesser harm than the regressions in standard I/O. Other changes since the 2012.09 release are also included in this point release: - add 'is-prime' and 'expmod' operations - enable smart matching against Signature literals - enable binding to signatures in declarators - add the 'is hidden' and base traits - temporarily remove the ability to change socket encodings (reverts to 2012.08's behavior) Both 2012.09 and 2012.09.1 contain a possibly breaking change from 2012.08: - class Iterable does not inherit from class Cool anymore This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Patrick R. Michaud, Jonathan Scott Duff, Solomon Foster If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#57) is scheduled for October 18, 2012. A list of the other planned release dates and code names for 2012 is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.10000644 000765 000024 00000005562 12573545401 020423 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #57 ("Tokyo") On behalf of the Rakudo development team, I'm thrilled to announce the October 2012 release of Rakudo Perl #57 "Tokyo". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The October 2012 release is code-named after Tokyo.pm, hosts of YAPC::Asia 2012. This release brings changes; some of them are outlined below: - delegation to methods using the handles trait - improved handling of :P5 regexes - reduced memory usage for Match objects - each REPL line no longer implies a fresh GLOBAL - import of custom meta-objects only affects the scope they are imported into - can now parse nested pairs of quote delimeters, like q{ foo q{ bar } baz } This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Patrick R. Michaud, Solomon Foster, diakopter, Timothy Totten If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#58) is scheduled for November 22, 2012. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.11000644 000765 000024 00000006013 12573545401 020414 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #58 ("Walnut") On behalf of the Rakudo development team, I'm thrilled to announce the November 2012 release of Rakudo Perl #58 "Walnut". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The November 2012 release is code-named after Walnut, home of "Yet Another Society" aka "The Perl Foundation". This release brings changes; some of them are outlined below: + 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 + regexes and quotes have better support for user-selected delimiters + heredocs + FIRST/NEXT/LAST can now be used in all types of loop (previously limited to for) This is only a small peek at the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Carl M�sak, Jonathan Scott Duff, Will "Coke" Coleda, Tobias Leich, Geoffrey Broadwell, Nicholas Clark, Konrad Borowski, flussence If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#59) is scheduled for December 20, 2012. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2012.12000644 000765 000024 00000006444 12573545401 020425 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #59 ("Warszawa") On behalf of the Rakudo development team, I'm proud to announce the December 2012 release of Rakudo Perl #59 "Warszawa". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The December 2012 release is code-named after Warszawa, home of Tadeusz Sośnierz (tadzik), whose contributions to Rakudo and the Perl 6 ecosystem during 2012 have been significant. Some of the changes in this release are outlined below: + The .indent method now has better handling of empty lines + Parse errors are much improved, and follow STD, the standard parser, much more closely; they are more accurate and more information is given + Rakudo now keeps parsing after some less serious errors + Better errors for various parse failures + The junction autothreader is now an order of magnitude faster + Texas versions of the Set and Bag operators implemented + Nested Pairs now give correct .perl output + { a => $_ } now correctly considered a block, not a hash as before This is only a small subset of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Tobias Leich, Solomon Foster, Timo Paulssen, Will "Coke" Coleda, Patrick R. Michaud, Amir E. Aharoni, Carl Mäsak, Geoff Broadwell, Shrivatsan Sampathkumar If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#60), assuming the world doesn't end today, is scheduled for January 17, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.01000644 000765 000024 00000007052 12573545401 020420 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #60 ("Sonoma") On behalf of the Rakudo development team, I'm proud to announce the January 2013 release of Rakudo Perl #60 "Sonoma". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The January 2013 release is code-named after Sonoma.pm, home of Geoff Broadwell (japhb), whose contributions to Rakudo and the Perl 6 ecosystem during 2012/2013 have been significant. Some of the changes in this release are outlined below: + 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 This is only a small subset of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Moritz Lenz, Carl Masak, Tobias Leich, Shrivatsan Sampathkumar If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#61), is scheduled for February 21, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. (And, have a good laugh at conspiracy theorists for their doomed end-of-world predictions!) [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.02000644 000765 000024 00000006105 12573545401 020417 0ustar00williamcoledastaff000000 000000 Announce: Rakudo Perl 6 compiler development release #61 ("drinkers") On behalf of the Rakudo development team, I'm proud to announce the February 2013 release of Rakudo Perl #61 "drinkers". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[*] -- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The February 2013 release is code-named after drinkers.pm, as even a camel needs to have a drink from time to time. Some of the changes in this release are outlined below: + "Did you mean ..." suggestions for symbol-not-found errors + Compile-time optimization of some cases of junctions in boolean context + IO::Socket.get now works again with non-Unicode characters + constant folding for routines marked as 'is pure' + natively typed variables and better error reporting in the REPL + speed up eqv-comparison of Bufs + warnings for useless use of (some) literals, variables and constant expressions in sink context This is only a small subset of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Timo Paulssen, Moritz Lenz, Jonathan Worthington, Tobias Leich, Arne Skjærholt, Carl Mäsak, Tadeusz Sośnierz, Will Coleda, Christoph Otto and Solomon Foster. If you would like to contribute, see , ask on the perl6-compiler@perl.org mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#62), is scheduled for March 21, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [*] What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.03.md000644 000765 000024 00000006027 12573545401 021022 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #62 ("Singapore") On behalf of the Rakudo development team, I'm proud to announce the March 2013 release of Rakudo Perl #62 "Singapore". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The March 2013 release is code-named after Singapore.pm. Some of the changes in this release are outlined below: * Rakudo warns when pure expressions are used in sink context * .substr(...) now correctly accepts whatever-star closures * Implemented shellwords postcircumfix (%h<< $x 'foo bar' >>) * Defining operators spelled like the empty string is now illegal * Array interpolations now properly do LTM * 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 This is only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, kboga, Tobias Leich, Moritz Lenz, Patrick R. Michaud, Timo Paulssen, Carl Mäsak, Tadeusz Sośnierz, Gerhard R, thundergnat, TimToady If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#63), is scheduled for April 18, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.04.md000644 000765 000024 00000005510 12573545401 021017 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #63 ("Albany") On behalf of the Rakudo development team, I'm proud to announce the April 2013 release of Rakudo Perl #63 "Albany". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The April 2013 release is code-named after Albany.pm. Some of the changes in this release are outlined below: * wrap low level VM objects in ForeignCode, allowing perl6 OO calls on them * for loops are eager again * add link and symlink to IO * add Capture.Bool() * improvements to DUMP() * various optimizations in the optimizer and the runtime * smartmatch against list now supports Whatever wildcards This is only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Geoffrey Broadwell, Jonathan Worthington, Moritz Lenz, Tobias Leich, Timo Paulssen, Will "Coke" Coleda, Carl Masak, Rob Hoelz, Tadeusz Sośnierz, Carl Mäsak, Brent Laabs, diakopter If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#64), is scheduled for May 23, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release. Take a deep breath. Write some new code. Don't forget to be awesome. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.05.md000644 000765 000024 00000006503 12573545401 021023 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #64 ("Austin") On behalf of the Rakudo development team, I'm proud to announce the May 2013 release of Rakudo Perl #64 "Austin". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ). The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The May 2013 release is code-named after Austin.pm. You'll see that this release is pure destiny. Its release number is 2**6, its codename has 6 chars, it is named after the place where the next YAPC::NA will happen on the sixth month of this year, a year with a crossfoot of 6. Some of the changes in this release are outlined below: * IO::Spec, a port of Perl 5's File::Spec * speedup of repeated shifts of large lists and arrays by 70%+ * regex special characters can be used as delimiters * allow slice with :exists adverb on hashes * fix regex interpolation slowdown * fix exporting of subroutines * 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 This is only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Brent Laabs, Moritz Lenz, Patrick R. Michaud, Tobias Leich, Jonathan Worthington, Will "Coke" Coleda, Elizabeth Mattijsen, dagurval, Carl Mäsak, Solomon Foster, Larry Wall, Tadeusz Sośnierz, Timo Paulssen, Arne Skjærholt, Timothy Totten If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#65), is scheduled for June 20, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release. Take a deep breath. Write some new code. Don't forget to be awesome. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.06.md000644 000765 000024 00000006223 12573545401 021023 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #65 ("Poznan") On behalf of the Rakudo development team, I'm proud to announce the June 2013 release of Rakudo Perl #65 "Poznan". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ) and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The June 2013 release is code-named after Poznan.pm, a mongers group that was founded after two Perl developers visiting this year's PLPW realized they lived in the same city. Some of the changes in this release are outlined below: + JVM backend added - passes initial sanity tests + type captures in signature binder implemented + IO::Handle methods gist, perl, path added + Int.msb and Int.lsb implemented + dir() is now lazy + $/ and $! now visible in eval/REPL + .{} adverb combinations all implemented + &first now returns Nil instead of failing + IO::Path.chmod implemented + Cool.path implemented + div and / fail with X::Numeric::DivisionByZero (rather than dying) This is only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Elizabeth Mattijsen, Stefan O'Rear, Brent Laabs, Tobias Leich, Timo Paulssen, Patrick R. Michaud, Will "Coke" Coleda, Moritz Lenz, thundergnat, Carl Mäsak, dagurval, bbkr If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#66), is scheduled for July 18, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.07.md000644 000765 000024 00000006002 12573545401 021017 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #66 ("Edinburgh") On behalf of the Rakudo development team, I'm proud to announce the July 2013 release of Rakudo Perl #66 "Edinburgh". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ) and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The July 2013 release is code-named after Edinburgh.pm, 'twas there that a now core hacker lived when he got involved with Perl 6. Some of the changes in this release are outlined below: + Huge progress in JVM backend (feature-wise almost on par with Parrot) + fixed handling of indented heredocs + basic support for threads and promises (JVM only) + implemented canonpath for Win32 IO::Spec + implemented squish + made []:(kv|p|k|v) work according to spec These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Elizabeth Mattijsen, Stefan O'Rear, Timo Paulssen, Solomon Foster, Brent Laabs, Tobias Leich, Will "Coke" Coleda, Carl Masak, Moritz Lenz, Donald Hunter, Stéphane Payrard, Patrick R. Michaud, Tadeusz Sośnierz, Larry Wall, GlitchMr If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#67), is scheduled for August 22, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.08.md000644 000765 000024 00000006332 12573545401 021026 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #67 ("Bicycle") On behalf of the Rakudo development team, I'm proud to announce the August 2013 release of Rakudo Perl #67 "Bicycle". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine (see ) and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The August 2013 release is code-named after Bicycle.pm, probably the Perl Mongers group with the coolest t-shirts. Some of the changes in this release are outlined below: + "is default", "is dynamic", "of" and "will" traits on variables + assigning Nil restores the default value + CALLER::<$var> now only works on dynamic variables, as per spec. + improvements to concurrency/parallelism support, including Channel, select, KeyReducer and basic asynchronous file reading (JVM only) + "once" phaser implemented + reimplementation of Buf as a role, and addition of Blob and other sized Buf/Blob related types + ConfigureJVM.pl now takes --gen-nqp, easing the Rakudo on JVM build + printf now correctly handles big integers These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Elizabeth Mattijsen, Jonathan Worthington, Moritz Lenz, Donald Hunter, Tobias Leich, Timo Paulssen, Solomon Foster, Tadeusz Sośnierz, Marton Papp, ivanoff, TimToady, Mouq, Patrick R. Michaud, awwaiid If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#68), is scheduled for September 19, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. In general, Rakudo development releases are scheduled to occur soon after each Parrot monthly release. Parrot releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.09.md000644 000765 000024 00000005635 12573545401 021034 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #68 ("Shanghai") On behalf of the Rakudo development team, I'm proud to announce the September 2013 release of Rakudo Perl #68 "Shanghai". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The September 2013 release is code-named after Shanghai.pm, a Perl Mongers group in a city visited by at least two Rakudo core developers. Some of the changes in this release are outlined below: + candidate argument to bless removed (per spec change) + @a.VAR.name and %h.VAR.name implemented + The $var.++ and $var.() syntaxes work + tr/// implemented + Sockets on JVM implemented These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Elizabeth Mattijsen, Moritz Lenz, Donald Hunter, Tobias Leich, Jonathan Worthington, Carl Mäsak, Geoffrey Broadwell, Paweł Murias, Solomon Foster, Will "Coke" Coleda, Dagur Valberg Johannsson, Tadeusz Sośnierz, BenGoldberg, GlitchMr, Mouq, timotimo If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#69), is scheduled for October 17, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release occurs soon after each Parrot monthly release is scheduled to occur. Parrot usually releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, to live life to its fullest, to cherish each moment, and to have fun. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.10.md000644 000765 000024 00000006035 12573545401 021017 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #69 ("Roederbergweg") On behalf of the Rakudo development team, I'm happy to announce the October 2013 release of Rakudo Perl #69 "Roederbergweg". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The October 2013 release is code-named after Roederbergweg.pm, a Perl Mongers group very near the recent Perl 6 Internals Workshop Some of the changes in this release are outlined below: + 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. These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Arne Skjærholt, Timo Paulssen, Carl Masak, Moritz Lenz, Tobias Leich, Alexander Moquin, Patrick R. Michaud, Elizabeth Mattijsen, grondilu, Jonathan Scott Duff, Will "Coke" Coleda If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#70), is scheduled for November 21, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release occurs soon after each Parrot monthly release is scheduled to occur. Parrot usually releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, step out of your comfort zone, and get a library card. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.11.md000644 000765 000024 00000006241 12573545401 021017 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #70 ("Malmö") On behalf of the Rakudo development team, I'm happy to announce the November 2013 release of Rakudo Perl #70 "Malmö". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The November 2013 release is code-named after Malmö, from which this release has been launched. Some of the changes in this release are outlined below: + Many concurrency primitives harmonized with new S17, but still pretty fluid + Refactored build system that allows building rakudo on rakudo/JVM 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 + improved run()/shell(), these return Proc::Status-objects now + The "gethostname" function implemented + Performance optimization: unfold junctions in 'when' clauses + various other bug fixes, optimisations and additional tests These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Moritz Lenz, Tobias Leich, Jonathan Worthington, Timo Paulssen, Will "Coke" Coleda, Mouq, Brian Gernhardt, Arne Skjærholt, L. Grondin, Geoffrey Broadwell, Steve Mynott, Andrew Egeler, Elizabeth Mattijsen If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#71), is scheduled for December 19, 2013. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release occurs soon after each Parrot monthly release is scheduled to occur. Parrot usually releases the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, step out of your comfort zone, and get a library card. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2013.12.md000644 000765 000024 00000005526 12573545401 021025 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #71 ("Advent") On behalf of the Rakudo development team, I'm happy to announce the December 2013 release of Rakudo Perl #71 "Advent". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^1] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The December 2013 release is code-named after Advent, the non-geographical group which fits this time of year. Some of the changes in this release are outlined below: + 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 These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Elizabeth Mattijsen, Timo Paulssen, Jonathan Worthington, Moritz Lenz, Tobias Leich, Larry Wall, Carl Mäsak If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#72), is scheduled for January 23, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to try the new release, step out of your comfort zone, and get a library card. [^1]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.01.md000644 000765 000024 00000007061 12573545401 021020 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #72 ("Plano") On behalf of the Rakudo development team, I'm happy to announce the January 2014 release of Rakudo Perl #72 "Plano". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine, the Java Virtual Machine and the Moar Virtual Machine[^1]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. The January 2014 release is code-named after Plano, because that suggestion was way better than "Three Blind Mice". hm, so what should we name this release... Fred Three Musketeers Three Stooges Three Blind Mice Three Little Pigs ... maybe we should name it Plano because that implies at least three dimensions oooh! +1 TimToady++ Some of the changes in this release are outlined below: + `Numeric.narrow` to coerce to narrowest type possible + Can now supply blocks with multiple arguments as sequence endpoints + The `eval` sub and method are now spelled `EVAL` + Method calls and hash/list access on `Nil` give `Nil` + Added support for MoarVM; passes >99% of the spectests that Rakudo JVM does + Implement more parts of `NativeCall` for the JVM + Fixed gather/take stack overflow bug in JVM backend These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite and the specification. The following people contributed to this release: Jonathan Worthington, Tobias Leich, Timo Paulssen, Moritz Lenz, Will "Coke" Coleda, Brian Gernhardt, Carl Masak, Rob Hoelz, Geoffrey Broadwell, Kevan Benson, Solomon Foster, grondilu, diakopter, Elizabeth Mattijsen, Mouq, Jonathan Scott Duff, Tadeusz Sośnierz, lue If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#73), is scheduled for February 20, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to enjoy the new release, try awesome stuff, and get back to us with feedback. [^1]: See and [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.02.md000644 000765 000024 00000006257 12573545401 021027 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #73 ("Karlsruhe.pm") On behalf of the Rakudo development team, I'm happy to announce the February 2014 release of Rakudo Perl 6 #73 "Karlsruhe.pm". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine, the Java Virtual Machine and the Moar Virtual Machine[^1]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This time it's the Perl Mongers group of Karlsruhe, Germany - where Timo Paulssen has been advertising Perl 6 to the other group members incessantly. Some of the changes in this release are outlined below: + The JVM now has full NativeCall support based on JNA. + The core of Rakudo::Debugger is now part of Rakudo itself and works across all backends. + "make" no longer itemizes its arguments. + for-loops at the statementlist level are now sunk by default. + better parsing of unspaces and formatting codes inside Pod blocks. + lots of improvements to the MoarVM backend including sockets and pipe opening. These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Jonathan Worthington, Tobias Leich, Mouq, Moritz Lenz, Timo Paulssen, Carl Masak, Larry Wall, Rob Hoelz, Jonathan Scott Duff, Matthew Wilson, Pepe Schwarz, Will "Coke" Coleda, Steve Mynott, raydiak, Geoffrey Broadwell, itz_, and Nicholas Clark. If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#74), is scheduled for March 20, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to enjoy the new release, try awesome stuff, have the appropriate amount of fun, and get back to us with feedback. [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.03.md000644 000765 000024 00000005577 12573545401 021034 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #74 ("Adelaide.pm") On behalf of the Rakudo development team, I'm happy to announce the March 2014 release of Rakudo Perl 6 #74 "Adelaide.pm". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine, the Java Virtual Machine and the Moar Virtual Machine[^1]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This time it's the Perl Mongers group of Adelaide. Some of the changes in this release are outlined below: + Fix for for-loops to be properly lazy + uniname, uniprop, and unival implemented on MoarVM backend + Numerous Pod parsing and formatting improvements + @ as shortcut for @$, % as shortcut for %$ + list infix reductions no longer flatten + Numerous compiler suggestion improvements These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Larry Wall, Alexander Moquin, Elizabeth Mattijsen, lue, Tobias Leich, Jonathan Worthington, Will "Coke" Coleda, Moritz Lenz, Arne Skjærholt and Reini Urban. If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#75), is scheduled for April 17, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to enjoy the new release, try awesome stuff, have the appropriate amount of fun, and get back to us with feedback. [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.04.md000644 000765 000024 00000006074 12573545401 021026 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #75 ("Echt") On behalf of the Rakudo development team, I'm happy to announce the April 2014 release of Rakudo Perl 6 #75 "Echt". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine, the Java Virtual Machine and the Moar Virtual Machine[^1]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This time it's the Perl Mongers group of Echt, who held their first meeting in about five years the other day. Some of the changes in this release are outlined below: + NativeCall passes all its tests on all backends + significant performance enhancement for MoarVM, spectest running 20%+ faster + S17 (concurrency) now in MoarVM (except timing related features) + winner { more @channels { ... } } now works + implemented univals(), .unival and .univals (on MoarVM) + added .minpairs/.maxpairs on (Set|Bag|Mix)Hash + Naive implementation of "is cached" trait on Routines These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Jonathan Worthington, Tobias Leich, Moritz Lenz, Carl Mäsak, Tadeusz Sośnierz, Nami-Doc, David Warring, Alexander Moquin, Timo Paulssen, lue, Donald Hunter, Andrew Egeler If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#76), is scheduled for May 22, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to enjoy the new release, try awesome stuff, have the appropriate amount of fun, and get back to us with feedback. [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.05.md000644 000765 000024 00000007315 12573545401 021026 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #76 ("Bajor") On behalf of the Rakudo development team, I'm happy to announce the May 2014 release of Rakudo Perl 6 #76 "Bajor". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine, the Java Virtual Machine and the Moar Virtual Machine[^1]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. I am sure there is a Perl Monger meeting in the Rakantha Province at the time of this writing. Some of the changes in this release are outlined below: + 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 + added IO::Notification.watch_path / IO::Path::watch which return a Supply of file system changes + added IO::Socket::Async.connect, .send, .chars_supply + added first-index, last-index, grep-index subs/methods + 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 + "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 These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Jonathan Worthington, Tobias Leich, Alexander Moquin, Moritz Lenz, Donald Hunter, Carl Masak, Timo Paulssen, lue, Tim Smith, Geoffrey Broadwell, Larry Wall, Filip Sergot, David Warring, Andrew Egeler, Jonathan Scott Duff, Solomon Foster If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#77), is scheduled for June 19, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to enjoy the new release, try awesome stuff, have the appropriate amount of fun, and get back to us with feedback. [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.06.md000644 000765 000024 00000006405 12573545401 021026 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #77 ("Gdańsk") On behalf of the Rakudo development team, I'm happy to announce the June 2014 release of Rakudo Perl 6 #77 "Gdańsk". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine, the Java Virtual Machine and the Moar Virtual Machine[^1]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. We hope there is a Perl Mongers group in Gdańsk after meeting Perl developers from Gdańsk during the PLPW this year. They proposed to organize PLPW next year. Some of the changes in this release are outlined below: + an initial implementation of S11 (Compilation Units) is now available + $*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 + IO::Socket::Async now also works on JVM + optimization: + .IO.{d,s,z} are now about 40% faster and return Failure if path doesn't exist + :a(:$b) and attributive binding + IO::Path.contents + push, unshift and comb + say, note + no-args case of @foo>>.bar + implement :42nd colonpair syntax These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Tobias Leich, Jonathan Worthington, Timo Paulssen, Donald Hunter, Pepe Schwarz, Moritz Lenz, Alexander Moquin, Filip Sergot, Rob Hoelz, Reini Urban, Geoff Broadwell If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#78), is scheduled for July 17, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to enjoy the new release, try awesome stuff, have the appropriate amount of fun, and get back to us with feedback. [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.07.md000644 000765 000024 00000006772 12573545401 021036 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #78 ("Sofia") On behalf of the Rakudo development team, I'm happy to announce the July 2014 release of Rakudo Perl 6 #78 "Sofia". Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine, the Java Virtual Machine and the Moar Virtual Machine[^1]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Sofia, the city where the YAPC::EU will take place in a little bit more than a month. Some of the changes in this release are outlined below: + 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 + subbuf-rw specced and implemented + minute value is optional in Timezone offsets in DateTime.new(), also a colon to delimit hours/minutes is now optional + the tr/// operator is implemented and has the proper return value + improved string handling for MoarVM backend + re-arranged infixish actions to support [[*]]= etc + all backends now allow C pointer arithmetic and casting of pointers to Perl 6 types (this funtionality is exposed by NativeCall) + fixed 'fail' so it also prints a backtrace + removed hack for $Inf/$NaN: constants Inf/NaN are exposed since a while + made initial/max threads introspectable + make .WHICH also work on type objects These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Jonathan Worthington, Tobias Leich, Timo Paulssen, Filip Sergot, Carlin, Will Coleda, Pepe Schwarz, Will Coleda, Carl Masak, Alexander Moquin, Andrew Egeler, Jonathan Scott Duff, Moritz Lenz If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#79), is scheduled for August 21, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, I encourage you to enjoy the new release, try awesome stuff, have the appropriate amount of fun, and get back to us with feedback. [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.08.md000644 000765 000024 00000006403 12573545401 021026 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #79 ("Minsk") On behalf of the Rakudo development team, I'm happy to announce the August 2014 release of Rakudo Perl 6 #79 "Minsk". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1], the Java Virtual Machine and the Parrot Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Minsk, the capital and largest city of Belarus. Some of the changes in this release are outlined below: + Many optimizations in both rakudo and the underlying VMs. + remove speed penalty of large ranges in character classes + quote words syntax \ splits on breakable space only + Add HyperWhatever / ** + ∅ is finally recognized as the empty set + 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 + can now call exit() in END blocks without hanging or affecting END block execution These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Tobias Leich, Jonathan Worthington, Alexander Moquin, Larry Wall, Rob Hoelz, Jonathan Scott Duff, Will "Coke" Coleda, Timo Paulssen, Pepe Schwarz, Moritz Lenz, Carlin, sergot, Carl Mäsak, Geoff Broadwell If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#80), is scheduled for September 18, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. On behalf of the development team, we encourage you to enjoy the new release, try awesome stuff, have the appropriate amount of fun, and get back to us with feedback. [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.09.md000644 000765 000024 00000006500 12573545401 021025 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #80 ("HongKong") On behalf of the Rakudo development team, I'm happy to announce the September 2014 release of Rakudo Perl 6 #80 "HongKong". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1], the Java Virtual Machine and the Parrot Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Hong Kong, where two Rakudo developers found themselves this month, sketching out an escape analysis implementation, eating delicious food, and looking at the pretty city blinkenlights by night. Some of the changes in this release are outlined below: + ./perl6 --profile for MoarVM + Workaround OS X make bug for MoarVM + support for submethod DESTROY (MoarVM only) + optimizations to Str.words, Str.lines, IO.lines, chomp, and return + added experimental support for Proc::Async, MoarVM only for now + Reduced memory size of CORE.setting, improved startup time + startup (on Moar) 15% faster than p5 w/ Moose These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Rob Hoelz, Larry Wall, Tobias Leich, Moritz Lenz, Jonathan Worthington, Will "Coke" Coleda, Alexander Moquin, Jonathan Scott Duff, Carl Masak, Steve Mynott, Timo Paulssen, usev6, leont, carlin, Geoff Broadwell, Solomon Foster, brrt If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#81), is scheduled for October 23, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list of IRC channel. Enjoy! [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.10.md000644 000765 000024 00000007110 12573545401 021013 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #81 ("Linz") On behalf of the Rakudo development team, I'm happy to announce the Octover 2014 release of Rakudo Perl 6 #81 "Linz". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1], the Java Virtual Machine and the Parrot Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Linz, because I really wanted to name this release "Salzburg" where the Austrian Perl Workshop was recently held, but there's no Salzburg.pm and Linz.pm was the closest Austria Perl Mongers group. :) Some of the changes in this release are outlined below: - strict pragma implemented and turned off for one-liners - Method form of .exists and .delete have finally been removed - Supply.lines/words and IO::Handle.words implemented, Str.words now lazy - Scoped directory manipulation: indir, tmpdir, homedir - Better deprecation messages - Various performance improvements These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". This is last release of Rakudo to support parrot without ICU. Future versions of Rakudo will require ICU support in the Parrot backend. Note: while this release does not require ICU support in Parrot, some tests in the standard Perl 6 test suite will nonetheless fail without it. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Jonathan Worthington, Tobias Leich, Moritz Lenz, Jonathan Scott Duff, Christian Bartolomäus, Brad Gilbert, Solomon Foster, Larry Wall, Pepe Schwarz, Timo Paulssen, Mikhail Khorkov, Will "Coke" Coleda, abraxxa, skids, Rob Hoelz, leont, laben, Patrick R. Michaud If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#82), is scheduled for November 20, 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list of IRC channel. Enjoy! [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.11.md000644 000765 000024 00000007420 12573545401 021020 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #82 ("Helsinki") On behalf of the Rakudo development team, I'm happy to announce the November 2014 release of Rakudo Perl 6 #82 "Helsinki". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1], the Java Virtual Machine and the Parrot Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Helsinki, in honour of the organizers of the Nordic Perl Workshop. Some of the changes in this release are outlined below: - 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' - Introduce IO::Handle.slurp-rest for slurping rest from handle - 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 - Various performance improvements and bugfixes These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". A note for OS X users: when running a spectest with a high number of parallel tests (e.g. with TEST_JOBS=8), it is likely you will see any number between 0 and 10 test-files with failures, usually because they abort midway through testing. Running these test-files then by themselves, shows no errors whatsoever. Current theory is that something in the MoarVM build on OS X is introducing random memory corruption. Any thoughts / suggestions / fixes will be deeply appreciated. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Tobias Leich, Larry Wall, Jonathan Scott Duff, Timo Paulssen, Alexander Moquin, Moritz Lenz, Steve Mynott, Christian Bartolomäus, Carl Mäsak, Pepe Schwarz, Rob Hoelz, Reini Urban, Geoff Broadwell, [Coke] If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#83), is scheduled for 18 December 2014. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list of IRC channel. Enjoy! [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2014.12.md000644 000765 000024 00000007771 12573545401 021032 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #83 ("Cologne") On behalf of the Rakudo development team, I'm happy to announce the December 2014 release of Rakudo Perl 6 #83 "Cologne". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1], the Java Virtual Machine and the Parrot Virtual Machine[^2]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^3] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Cologne, in honour of the organizers of the Niederrhein.PM meeting this week. Some of the changes in this release are outlined below: These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". INCOMPATIBLE CHANGES: + $str ~~ s/// now returns a Match or list of Matches Other notable changes: + Flakiness on OS X has been fixed (for the most part) + Method FALLBACK implemented + Updated List smart-matching to latest design + $*DISTRO and $*KERNEL updated ($*DISTRO now actually report the Linux dist) + 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 + Many optimizations, bug-fixes and other additions The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Larry Wall, Jonathan Worthington, Rob Hoelz, Moritz Lenz, Tobias Leich, Timo Paulssen, Christian Bartolomäus, Carl Mäsak, Solomon Foster, Geoffrey Broadwell, Will "Coke" Coleda, raydiak, Alexander Moquin If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#84), is scheduled for 22 January 2015. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list of IRC channel. Enjoy! [^1]: See [^2]: See [^3]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. # Troubleshooting It appears that on OS X, the build will sometimes fail with a message like: .../install/include/libuv/uv-darwin.h:26:11: fatal error: 'mach/mach.h' file not found The only solution found to fix this so far, has been: $ cd install/include/libuv $ ln -s /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk/usr/include/mach $ cd ../../.. $ # run make again Note that the 10.9 in the above, represents the major version of OS X being used. On Mavericks use 10.9 (like above), on Yosemite use 10.10. rakudo-2015.11/docs/announce/2015.01.md000644 000765 000024 00000006546 12573545401 021030 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #84 (“Gotanda”) On behalf of the Rakudo development team, I’m happy to announce the January 2015 release of Rakudo Perl 6 #84 “Gotanda”. Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1], the Java Virtual Machine and the Parrot Virtual Machine[^2]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^3] --- it’s announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Gotanda.pm Some of the changes in this release are outlined below: These are only some of the changes in this release. For a more detailed list, see “docs/ChangeLog”. INCOMPATIBLE CHANGES: + None this release Other notable changes: + 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 + New simple way of creating an object hash: :{} + Substitution now supports assignment meta-op, e.g. s[\d+] += 2 + Many memory and CPU optimizations + Supply.for deprecated in favour of Supply.from-list The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Moritz Lenz, Pepe Schwarz, Jonathan Worthington, Larry Wall, Tobias Leich, ab5tract, Christian Bartolomäus, Rob Hoelz, Donald Hunter, Timo Paulssen, raydiak, Geoffrey Broadwell, Alexander Moquin, Yun SangHo, skids, Lucas Buchala, Will Coleda, Solomon Foster, Steve Mynott, ugexe, Carl Mäsak, pmurias, woolfy If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#85), is scheduled for 19 February 2015. A list of the other planned release dates and code names for future releases is available in the “docs/release_guide.pod” file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you’re using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list of IRC channel. Enjoy! [^1]: See [^2]: See [^3]: What’s the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the “Using Perl 6” book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what’s possible with Rakudo Perl 6 and provide feedback on what works, what doesn’t, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.02.md000644 000765 000024 00000014635 12573545401 021027 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #85 (“Berlin”) On behalf of the Rakudo development team, I’m happy to announce the February 2015 release of Rakudo Perl 6 #85 “Berlin”. Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1], the Java Virtual Machine and the Parrot Virtual Machine[^2]. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^3] --- it’s announcing a new release of the compiler only. For the latest Rakudo Star release, see . As described by pmichaud in a recent blog post: http://pmthium.com/2015/02/suspending-rakudo-parrot/ this is the *last* release of Rakudo that supports Parrot as a backend for the foreseeable future. Whether Parrot support can be restored at some point in the future, really depends on people with tuits making the necessary changes. In that light, I would like to emphasize the last paragraph of said blog post: If there are people that want to work on refactoring Rakudo’s support for Parrot so that it’s more consistent with the other VMs, we can certainly point them in the right direction. For the GLR this will mainly consists of migrating parrot-specific code from Rakudo into NQP’s APIs. For the NSA and NFG work, it will involve developing a lot of new code and feature capabilities that Parrot doesn’t possess. The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Berlin.pm for several reasons: + Historically, Berlin has been known to be a divided city. Just over 25 years ago, the miracle of reunification started. Berlin today is a thriving city, still redefining itself. The fact that this release will most likely be the last release supporting Parrot, signifies a division that we hope will be undone in the future. The history of Berlin should be an inspiration for this. + In April 2015, the next Perl QA Hackathon will take place in Berlin. This hackathon will be attended by developers who will be working on both Perl 5 as well as Perl 6. A further sign of reunification. Some of the changes in this release are outlined below: These are only some of the changes in this release. For a more detailed list, see “docs/ChangeLog”. INCOMPATIBLE CHANGES: + On MoarVM, symlinks are now followed. This means that e.g. a given path can have both .l and .d be true, if the symlink points to a directory. This behaviour now matches the behaviour on the Parrot and JVM backend, therefore one could consider this a bug fix, rather than an incompatible change. + Overriding invoke/postcircumfix:<( )> for type coercions (ex. MyType(...)) now passes the function arguments as-is, rather than just passing a Capture containing them. To get the old behavior, simply declare a Capture parameter (|c). + "6;" at unit start is no longer a way to say "no strict;". It was deemed to be a bad meme and huffmannized inappropriately. + The NativeCall module (for incorporating external libraries as Perl 6 subs) is now part of the compiler distribution. To activate it, one must still do a "use NativeCall", but it does *not* have to be installed with panda anymore. If you are a module developer, you can now remove NativeCall as a prerequisite from the meta information of your distribution. Other notable changes: + Coercion syntax now works in signatures: sub foo(Str(Any) $a) { ... } will take Any value as its first positional parameter, and coerce it to Str before making it available in $a. Note that Str(Any) can be shortened to Str(). + "sub MAIN;" (as in, rest of file is the MAIN unit) has been implemented. + Metaop "=" now respects the precedence of the op it is meta-ing. + Added numerical "polymod" method: $seconds.polymod(60,60,24) will give you a list with seconds, minutes, hours, days. + Added rational "base-repeating" method: (1/7).base-repeating(10) will give you a base of "0." and a repeating factor of "142857". In contrast, printf("%0.20f",1/7) would give you 0.14285714285714300000, which is less accurate. + Repeated mixins of the same role and same type are now 10x faster, and use much less memory. Str.trans, tr/// and Str.subst on simple Str, are now about 20x faster. + Many optimizations, improved error messages and bugs fixed (over 200 commits to Rakudo since the 2015.01 release). The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Alexander Moquin, Moritz Lenz, Tobias Leich, Jonathan Worthington, Larry Wall, Will "Coke" Coleda, Timo Paulssen, Rob Hoelz, Andrew Egeler, Paul Cochrane, Stefan Seifert, Brad Gilbert, Mikhail Khorkov, Pepe Schwarz, avuserow, nwc10, skids, mj41, Tux, raydiak, Elizabeth Mattijsen If you would like to contribute, see , ask on the mailing list, or ask on IRC \#perl6 on freenode. The next release of Rakudo (#86), is scheduled for 19 March 2015. A list of the other planned release dates and code names for future releases is available in the “docs/release_guide.pod” file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you’re using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list of IRC channel. Enjoy! [^1]: See [^2]: See [^3]: What’s the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Nothing else. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the “Using Perl 6” book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what’s possible with Rakudo Perl 6 and provide feedback on what works, what doesn’t, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.03.md000644 000765 000024 00000013645 12573545401 021030 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #86 (“Cluj”) On behalf of the Rakudo development team, I’m happy to announce the March 2015 release of Rakudo Perl 6 #86 “Cluj”. Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^3] --- it’s announcing a new release of the compiler only. For the latest Rakudo Star release, see . As described by pmichaud in a recent blog post: http://pmthium.com/2015/02/suspending-rakudo-parrot/ this is the first release of Rakudo that does *not* support Parrot [^2] as a backend. Whether Parrot support can be restored at some point in the future, really depends on people with tuits making the necessary changes. In that light, I would like to emphasize the last paragraph of said blog post: If there are people that want to work on refactoring Rakudo’s support for Parrot so that it’s more consistent with the other VMs, we can certainly point them in the right direction. For the GLR this will mainly consists of migrating parrot-specific code from Rakudo into NQP’s APIs. For the NSA and NFG work, it will involve developing a lot of new code and feature capabilities that Parrot doesn’t possess. The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This release is named after Cluj.pm which just celebrated its third birthday. Some of the changes in this release are outlined below: These are only some of the changes in this release. For a more detailed list, see “docs/ChangeLog”. + Incompatible changes and deprecations: + 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. + Deprecate IO::Handle.input-line-separator for .nl + 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 + Add a array[T], usable for native int/num (MoarVM only for now) + Other native improvements, e.g. my int $a; $a++ + Implement IO::Path.resolve on r-m/POSIX + Fixes + Fix JVM runner generation on Windows. + 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 s/// up to 25% faster + Make substr(-rw) about 10% faster + Test.pm changes + 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 The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Jonathan Worthington, Larry Wall, Tobias Leich, ugexe, Alexander Moquin, Moritz Lenz, Timo Paulssen, Pepe Schwarz, Andrew Egeler, Christian Bartolomäus, Kamil Kułaga, Solomon Foster, Geoffrey Broadwell, Jonathan Scott Duff, Paul Cochrane, Carl Masak, Will "Coke" Coleda, raydiak, Donald Hunter, Stefan Seifert, Rob Hoelz, sue spence, Brad Gilbert, Ven, Steve Mynott, [Tux], Nicholas Clark, avuserow If you would like to contribute, see , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#87), is scheduled for 23 April 2015. A list of the other planned release dates and code names for future releases is available in the “docs/release_guide.pod” file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you’re using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: See [^3]: What’s the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the “Using Perl 6” book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what’s possible with Rakudo Perl 6 and provide feedback on what works, what doesn’t, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.04.md000644 000765 000024 00000007305 12573545401 021025 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #87 ("Vladivostok") On behalf of the Rakudo development team, I'm happy to announce the April 2015 release of Rakudo Perl 6 #87 "Vladivostok". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This month's release is named after Vladivostok, because we've run out of .pm groups in China. Some of the changes in this release are outlined below: * 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 * numerous small fixes * native arrays * 'bit' and 'byte' native types * starts-with/substr-eq/ends-with for comparing strings inside other strings * basic implementation of Uni, NFC, NFD, NFKC, and NFKD on Moar backend * where constraints on variable and attribute declarations * 'is rw' parameters implemented for native subs (they get passed as a pointer) * Str.codes/chars/uc/lc/tc/tclc/ord/flip about 25% faster * use Foo:from\ and EVAL $code, :lang\ are now supported as long as Inline::Perl5 is installed. Allows passing most of S01 spec tests. * many smaller speedups These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Jonathan Worthington, Larry Wall, Elizabeth Mattijsen, Tobias Leich, Pepe Schwarz, Moritz Lenz, Will "Coke" Coleda, Carl Mäsak, Alexander Moquin, raydiak, Brent Laabs, Christian Bartolomäus, Timo Paulssen, Jonathan Stowe, Stefan Seifert, Jonathan Scott Duff, Rob Hoelz, Edwin Steiner, Geoffrey Broadwell, nwc10, eli-se, lucasb If you would like to contribute, see , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#88), is scheduled for 21 May 2015. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.05.md000644 000765 000024 00000011103 12573566321 021021 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #88 ("Dresden") On behalf of the Rakudo development team, I'm happy to announce the May 2015 release of Rakudo Perl 6 #88 "Dresden". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This month's release is named after Dresden, where this year's German Perl Workshop happened. Some of the changes in this release are outlined below: * NFG, NFC, NFD, Uni * Implemented CLIENT:: (nearest CALLER:: from different package) * Implemented "is nodal" for signalling behaviour under hypers * Rudimentary tab completion available via the Linenoise module * "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. * .pick($n)/roll($n) now always return lists, even when $n == 1 * $?FILE is now always an absolute path * The "is cached" trait no longer works on methods, throws a NYI instead * Method .map should be used instead of .for * Test.pm functions are now kebab-cased (e.g. throws_like -> throws-like) * Hashes use much less memory on Moar * The REPL is strict by default now, that leaves only '-e' lines to be lax * site/lib is now in the C library (.dll/.so/.dylib etc) search path * generating backtraces is now lazy, improving the speed of e.g. warnings * Implement new @*INC handling (about 30% faster startup time) (bare startup time is now below 100 ms on some machines) * Implemented CUnions which map to the union C type definition for NativeCall * Implemented HAS declarator for attributes to mark it embedded into the CStruct or CUnion These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Jonathan Worthington, Tobias Leich, Sterling Hanenkamp, Arne Skjærholt, Paul Cochrane, Larry Wall, Rob Hoelz, Carl Masak, raydiak, Timo Paulssen, Christian Bartolomäus, Will "Coke" Coleda, Bart Wiegmans, Moritz Lenz, Jonathan Stowe, skids, Pepe Schwarz, Brent Laabs, Steve Mynott, Jeffrey Goff, Solomon Foster, Radek Slupik, Elise, tony-o, Stefan Seifert, Jimmy Zhuo, Nicholas Clark, Brad Gilbert, Nick Logan, ven, lembark, Justin DeVuyst, David Warring, Xinyuan Wang, David Farrell If you would like to contribute, see , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#89), is scheduled for 18 June 2015. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.06.md000644 000765 000024 00000006715 12573566321 021037 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #89 ("Salt Lake") On behalf of the Rakudo development team, I'm happy to announce the June 2015 release of Rakudo Perl 6 #89 "Salt Lake". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This month's release is named after Salt Lake City, where this year's YAPC::NA happened. Some of the changes in this release are outlined below: * Lexical pragma 'use trace' now outputs statements on STDERR * $=finish now contains text after first =finish/=for finish/=begin finish * Added :as named param to .classify / .categorize * EVALFILE added, for evalling source in a file * Implemented 'quietly' statement prefix to prevent warnings being issued * 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 These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on Parrot, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Tobias Leich, Jonathan Worthington, Timo Paulssen, Rob Hoelz, Christian Bartolomäus, Will "Coke" Coleda, Bart Wiegmans, Larry Wall, Moritz Lenz, Justin DeVuyst, Steve Mynott, Carl Masak, Solomon Foster, cygx, smls, Alexander Moquin, Jonathan Stowe, Brent Laabs, Dagur Valberg Johannsson, Sam S If you would like to contribute, see , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#90), is scheduled for 23 July 2015. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.07.md000644 000765 000024 00000006734 12573576073 021046 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #90 ("Prague") On behalf of the Rakudo development team, I'm happy to announce the July 2015 release of Rakudo Perl 6 #90 "Prague". Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it's announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This month's release is named after Prague, new home to one of the Rakudo core developers. Some of the changes in this release are outlined below: * Cool.substr(-rw) and &substr(-rw) now also accept a Range * Added trait "is required" on class attributes * &?ROUTINE and &?BLOCK * &words implemented (to completement .words) * Numeric comparison ops (== > etc) for DateTimes * samewith() now also works in subs * Calling the .clone method with alternate values no longer changes original * .grep and &grep now consume multiple elements for many-param blocks * ENTER phaser now can be used as an r-value These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on the design docs, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Jonathan Worthington, Elizabeth Mattijsen, Tobias Leich, skids, Moritz Lenz, Christian Bartolomäus, Jonathan Scott Duff, Nick Logan, Timo Paulssen, Carl Mäsak, Steve Mynott, Larry Wall, Rob Hoelz, Jonathan Stowe, Will "Coke" Coleda, Jimmy Zhuo, Stefan Seifert, Faye Niemeyer, David H. Adler, Bart Wiegmans, Lucas Buchala, Paul Cochrane, Cédric Vincent, Stéphane Payrard, Brent Laabs, Daniel Dehennin, Geoff Broadwell, Sue, Sue Spence, smls, ab5tract, Dmitriy Olshevskiy If you would like to contribute, see , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#91), is scheduled for 20 August 2015. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: What's the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the "Using Perl 6" book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what's possible with Rakudo Perl 6 and provide feedback on what works, what doesn't, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.08.md000644 000765 000024 00000004253 12600026162 021015 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, August 2015 scheduled release On behalf of the Rakudo development team, I'd like to announce that we have skipped the regularly scheduled release planned for August 2015. The team has been working hard on finishing the GLR (Great List Refactor) which is one of the last disruptive changes planned before we are able to release a candidate that might be eligible for Christmas. Many of our developers were able to get together and work on this and other items at the recent Swiss Perl Workshop, but the schedule of the workshop and the amount of work involved made it difficult to complete the work in time for the scheduled August release. Our plan now is to include the work done as part of the GLR in the *next* scheduled monthly release. We will also remove all the functionality that has been deprecated - we've been warning about this for some time, and we want to give the module ecosystem a chance to deal up with these last set of disruptive changes before the Christmas release this year. Thank you for your patience as we work to bring you the best version of Perl 6 that we can. Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on the design docs, the Perl 6 test suite, MoarVM and the specification. If you would like to contribute, see , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#91), is scheduled for 17 September 2015. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you're using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See rakudo-2015.11/docs/announce/2015.09.md000644 000765 000024 00000010175 12600027417 021022 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #91 (“Zürich”) On behalf of the Rakudo development team, I’m happy to announce the September 2015 release of Rakudo Perl 6 #91 “Zürich”. Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it’s announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This month’s release is named after Zürich Perl Mongers, hosts of the recent Swiss Perl Workshop. Some of the changes in this release are outlined below: * Great List Refactor - See http://design.perl6.org/S07.html * All Deprecations removed in preparation for Christmas release * Added support for calling into C++ libraries and calling methods on C++ classes * 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 * All Unicode digits can now be part of literal numbers * `val()` and allomorphic types implemented * Most European quoting styles are now supported * New $[...] and ${...} constructs allow prefix itemization * The .gist and .perl methods can now deal with self-referential structures These are only some of the changes in this release. For a more detailed list, see "docs/ChangeLog". Apologies, there are a few failures in the JVM test suite this month, as we’ve been focusing on our primary backend, MoarVM. Please bear with us. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on the design docs, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Jonathan Worthington, Stefan Seifert, Elizabeth Mattijsen, Tobias Leich, Moritz Lenz, Pawel Murias, Larry Wall, Faye Niemeyer, Rob Hoelz, skids, Jimmy Zhuo, Timo Paulssen, Will "Coke" Coleda, Solomon Foster, Paul Cochrane, Pepe Schwarz, David Warring, Jonathan Scott Duff, Christian Bartolomäus, Nick Logan, niner, laben, Brent Laabs, Carl Masak, Kamil Kułaga, Francois Perrad, Bart Wiegmans, Ben Tyler, Geoffrey Broadwell, Leon Timmermans, Will Coleda, Justin DeVuyst, Steve Mynott, alexghacker, vendethiel, Tim Smith, Jonathan Stowe, David Warring, Carl Mäsak, sergot, Stéphane Payrard, Daniel Dehennin, Mike Francis, Sue Spence, Zoffix Znet If you would like to contribute, see , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#92), is scheduled for 22 October 2015. A list of the other planned release dates and code names for future releases is available in the "docs/release_guide.pod" file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you’re using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: What’s the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the “Using Perl 6” book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what’s possible with Rakudo Perl 6 and provide feedback on what works, what doesn’t, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.10.md000644 000765 000024 00000010761 12612422576 021023 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #92 (“Niceville”) On behalf of the Rakudo development team, I’m very happy to announce the October 2015 release of Rakudo Perl 6 #92 “Niceville”. Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. This is the “Birthday” release of Rakudo Perl 6; It’s the first release candidate/beta of the compiler for the anticipated 6.0 “Christmas” release. The “Christmas” release will occur on or about 17 December 2015, assuming no critical bugs are found between now and then. Please try the release, your feedback is greatly appreciated. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it’s announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This month’s release is named after the Niceville chapter, because it sounds like a wonderful, magical place. Some of the changes in this release are outlined below: + 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. + New operator 'infix o' for function composition + 'fc' for Unicode-correct case folding implemented + grep now accepts :k, :v, :kv, :p attributes + 'Supply.throttle' for rate-limiting + 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 + 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 built-in methods that return iterables are now much faster + Better error messages when comparing version strings with numbers + Several error messages that were lacking line numbers now include them These are only some of the changes in this release. For a more detailed list, see “docs/ChangeLog”. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on the design docs, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Elizabeth Mattijsen, Larry Wall, Jonathan Worthington, Pawel Murias, Christian Bartolomäus, Tobias Leich, Stefan Seifert, Will "Coke" Coleda, Pepe Schwarz, Francois Perrad, skids, Rob Hoelz, Faye Niemeyer, Moritz Lenz, Jimmy Zhuo, Timo Paulssen, Stéphane Payrard, cygx, Nick Logan, Solomon Foster, tony-o, Bart Wiegmans, Steve Mynott, diakopter, niner, Tokuhiro Matsuno, Carl Mäsak, Nicholas Clark, thundergnat, Jonathan Scott Duff, Shoichi Kaji, sue spence, David Warring If you would like to contribute or find out more information, visit , , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#93), is scheduled for 19 November 2015. A list of the other planned release dates and code names for future releases is available in the “docs/release_guide.pod” file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you’re using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: What’s the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the “Using Perl 6” book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what’s possible with Rakudo Perl 6 and provide feedback on what works, what doesn’t, and what else they would like to see included in the distribution. rakudo-2015.11/docs/announce/2015.11.md000644 000765 000024 00000011011 12623477246 021017 0ustar00williamcoledastaff000000 000000 # Announce: Rakudo Perl 6 compiler, Development Release #93 (“Bend”) On behalf of the Rakudo development team, I’m very happy to announce the November 2015 release of Rakudo Perl 6 #93 “Bend”. Rakudo is an implementation of Perl 6 on the Moar Virtual Machine[^1] and the Java Virtual Machine. This is the final pre-Christmas release of Rakudo Perl 6. It’s the second release candidate/beta of the compiler for the anticipated 6.0 “Christmas” release. The “Christmas” release will occur on or about 17 December 2015, assuming no critical bugs are found between now and then. Please try the release, your feedback is greatly appreciated. The tarball for this release is available from . Please note: This announcement is not for the Rakudo Star distribution[^2] --- it’s announcing a new release of the compiler only. For the latest Rakudo Star release, see . The Rakudo Perl compiler follows a monthly release cycle, with each release named after a Perl Mongers group. This month’s release is named after the Bend chapter, because we’re nearly around the bend with the upcoming Christmas release. Some of the changes in this release are outlined below: New in 2015.11: + Initial shaped array support + \r\n (Carriage Return/LineFeed) is now a single (synthetic) grapheme + Unicode support adheres to Unicode Annex #29 + Unicode quotes are now also allowed in regular expressions + Improved newline support with "use newline" and updates to IO::Handle + Added List.head, List.tail, List.repeated methods + Str.encode now allows :replacement parameter for unencodable sequences + Str.split now accepts multiple strings to split on + New Range.int-bounds returns first/last value for integer ranges + Auto-generated meta-ops vivified by referring to them, instead of executing + Illegal assignment of different Numeric values now caught at compile time + &nextcallee implemented, which returns the routine that nextsame would invoke + Many speedups These are only some of the changes in this release. For a more detailed list, see “docs/ChangeLog”. The development team thanks all of our contributors and sponsors for making Rakudo Perl possible, as well as those people who worked on the design docs, the Perl 6 test suite, MoarVM and the specification. The following people contributed to this release: Jonathan Worthington, Elizabeth Mattijsen, Larry Wall, Pawel Murias, Will "Coke" Coleda, Christian Bartolomäus, Pepe Schwarz, Timo Paulssen, Tobias Leich, Mike Francis, Nicholas Clark, Dagfinn Ilmari Mannsåker, Moritz Lenz, Steve Mynott, Jens Rehsack, cygx, Stefan Seifert, Jimmy Zhuo, Nick Logan, Lucas Buchala, Zoffix Znet, Donald Hunter, Lloyd Fournier, Ronald Schmidt, Bart Wiegmans, Tomasz Konojacki, Sterling Hanenkamp, Vladimir Lettiev, Faye Niemeyer, johnspurr, Tim Smith, Rob Hoelz, grondilu If you would like to contribute or find out more information, visit , , ask on the mailing list, or ask on IRC #perl6 on freenode. The next release of Rakudo (#94), is tentatively scheduled for 17 December 2015. Because that release will correspond with the Perl 6 Christmas version of the specification, we may end up delaying the release to insure the best possible release. A list of the other planned release dates and code names for future releases is available in the “docs/release_guide.pod” file. A Rakudo development release typically occurs a few days (often two) after the third Tuesday of each month. The development team appreciates feedback! If you’re using Rakudo, do get back to us. Questions, comments, suggestions for improvements, cool discoveries, incredible hacks, or any other feedback -- get in touch with us through (the above-mentioned) mailing list or IRC channel. Enjoy! [^1]: See [^2]: What’s the difference between the Rakudo compiler and the Rakudo Star distribution? The Rakudo compiler is a compiler for the Perl 6 language. Not much more. The Rakudo Star distribution is the Rakudo compiler plus a selection of useful Perl 6 modules, a module installer, the most recent incarnation of the “Using Perl 6” book, and other software that can be used with the Rakudo compiler to enhance its utility. Rakudo Star is meant for early adopters who wish to explore what’s possible with Rakudo Perl 6 and provide feedback on what works, what doesn’t, and what else they would like to see included in the distribution. rakudo-2015.11/docs/architecture.html000644 000765 000024 00000012235 12573545401 021432 0ustar00williamcoledastaff000000 000000 How Rakudo compiles a Perl 6 program

How Rakudo compiles a Perl 6 program

Parser and Action Methods

The Perl 6 source code is transformed in various stages, of which the first two are the Parser and Action Method stages. The Parser creates a parse tree out of the Perl 6 source code and then gives control to appropriate action methods that annotate the parse tree, incrementally turning it into an Abstract Syntax Tree (AST). When an action method is done annotating, control is handed back to the parser, which then continues parsing the Perl 6 code and "fire off" new action methods as it goes.

The result of these two stages interacting is an "improved PAST" (Perl 6 Abstract Syntax Tree) called QAST. This tree is then passed on to the QAST compiler.

The parser and action methods are implemented in "Not Quite Perl 6" (NQP) and are part of Rakudo and hosted in the Rakudo repository at src/Perl6/Grammar.pm and src/Perl6/Actions.pm.

The World

The World is where the parser and the action methods store any declarations they encounter during their runs, including Classes, Types, Signatures, Constants, Subs and Methods.

QAST compiler

The QAST compiler transforms the abstract syntax tree into a PIRT (Parrot Intermediate Representation Tree). To do this, the QAST compiler does a series of translations on the AST, creating PIRT nodes that implement the operations specified by the QAST nodes.

In addition, the QAST compiler is responsible for serializing The World in such a way that later stages can get access to the declarations stored there during the parser and action methods stages.

There's also opportunity to apply some VM-specific optimizations at this point. When this is done, the resulting PIRT is passed to the PIRT serializer.

This stage is described in the different files in the nqp/src/QAST/ directory.

PIRT serializer

The PIRT serializer "squashes" the PIR Tree into a format that can be passed to Parrot itself and it's IMCC (InterMediate Code Compiler) stage.

You can read more about this at nqp/src/QAST/PIRT.nqp.

IMCC and Parrot runtime

The IMCC (InterMediate Code Compiler) receives the PIR code from the PIRT serializer and then transforms it into Parrot Byte Code (PBC). IMCC is parrot's PIR compiler, written in C and statically linked into parrot. The byte code can then be stored to disk or executed in memory by one of the run cores available as part of the Parrot runtime. This is in some sense the heart of Parrot - or one of the hearts; There are several different cores available, including one for just-in-time compilation (JIT), one for debugging and others.

You can find out more about the IMCC in the parrot/docs/imcc/ directory, and about the different run cores in the parrot/docs/running.pod

PMCs and dynops

There are also some supporting custom types and operations in Rakudo called dynamic PMCs and dynamic ops (dynops) which are written in C, and helper functions written in NQP and PIR. These supporting libraries exist for adding features to Parrot that are needed to handle special features in Perl 6.

Core setting library

The core settings library is the library containing the methods, classes and almost all other features that make up the Rakudo Perl 6 implementation. This library is tightly coupled with the perl6 binary, and loaded by default every time perl6 is run.

Glossary

NQP
Not Quite Perl 6, a small subset of Perl 6 that is used for tree transformations in compilers.
PIR
Parrot Intermediate Representation, the most commonly used for of parrot assembly (which is still high-level enough to be written by humans).
IMCC
InterMediate Code Compiler, the part of parrot that compiles PIR into byte code.
PBC
Parrot Byte Code, the binary form to which all parrot programs are compiled in the end.
Core setting
The core setting is the Perl 6 standard library. It is part of the perl6 executable, and contains all the standard features available in Perl 6.
QAST
The "improved" Abstract Syntax Tree used in Rakudo Perl 6. It contains information about how the program is structured, and what it is supposed to do.
PIRT
Parrot Intermediate Representation Tree.
rakudo-2015.11/docs/architecture.svg000644 000765 000024 00000063432 12573545401 021272 0ustar00williamcoledastaff000000 000000 Rakudo Perl 6 Architecture image/svg+xml Rakudo Perl 6 Architecture rakudo architecture Mortiz Lentz The Perl Foundation https://raw.github.com/rakudo/rakudo/nom/docs/architecture.svg https://raw.github.com/rakudo/rakudo/nom/docs/architecture.html en-US Core setting(Perl 6) The Perl 6 source code is transformed in various stages. The first one is the parser stage, which creates a parse tree out of the Perl 6 source code. The parser stage is implemented in "Not Quite Perl 6" (NQP) and is part of Rakudo and hosted in the Rakudo repository. Parser (NQP) Parser (NQP) The action methods are applied to the parse tree at the same time as the parser builds it. The result of this process is the Abstract Syntax Tree that is sent to the QAST compiler. Action methods (NQP) Action methods (NQP) Perl 6source QAST PIRT serializer (NQP) QAST compiler (NQP) IMCC (C) PIRT PIR The POST compiler emits PIR, which IMCC transforms into byte code. IMCC is parrot's PIR compiler, written in C and statically linked into parrot. The byte code (PBC) can then be stored to disk, or executed in memory by a so-called run core or run loop, which is in some sense the heart of parrot - or one of the hearts, because there are several different ones available (one for just-in-time compilation (JIT), one for debugging etc.). There are also some supporting custom types and operations in Rakudo called dynamic PMCs and dynamic ops which are written in C, and helper functions written in other languages (namely NQP and PIR). Those do not show up in the flow chart. Parrot runtime (C) Parrot runtime (C) PBC PMC &dynops (C) JAST serializer (NQP) QAST compiler (NQP) Java Virtual Machine JAST JVM Perl6::World(NQP) MAST serializer (NQP) QAST compiler (NQP) MoarVM MAST moar rakudo-2015.11/docs/compiler_overview.pod000644 000765 000024 00000030075 12573545401 022330 0ustar00williamcoledastaff000000 000000 ## $Id$ =head1 RAKUDO COMPILER OVERVIEW =head2 How the Rakudo Perl 6 compiler works This document describes the architecture and operation of the Rakudo Perl 6 (or simply Rakudo) compiler. The F describes how to build and run Rakudo. Rakudo has six main parts summarized below. Source code paths are relative to Rakudo's F directory, and platform specific filename extensions such as F<.exe> are sometimes omitted for brevity. =over 4 =item 1. Not Quite Perl builds Perl 6 source code parts into Rakudo =item 2. A main program drives parsing, code generation and runtime execution (F) =item 3. A grammar parses user programs (F) =item 4. Action methods build a Parrot Abstract Syntax Tree (F) =item 5. Parrot extensions provide Perl 6 run time behavior (F, F, F) =item 6. Libraries provide functions at run time (F, F, F, F, F) =back The F (generated from F<../tools/build/Makefile.in> by F<../Configure.pl>) compiles all the parts to form the F executable and the F or F "fake executable". We call it fake because it has only a small stub of code to start the Parrot virtual machine, and passes itself as a chunk of bytecode for Parrot to execute. The source code of the "fakecutable" is generated as F with the stub at the very end. The entire contents of F are represented as escaped octal characters in one huge string called C. What a hack! =head2 1. NQP The source files of Rakudo are preferably and increasingly written in Perl 6, the remainder in Parrot Intermediate Representation (PIR) or C. Not Quite Perl (nqp) provides the bootstrap step of compiling compiler code (yes!) written in a subset of Perl 6, into PIR. The latest version of NQP includes the I<6model> library, which is the building block for all Perl 6 object. It also comes with a regex engine that Rakudo uses. NQP is a bootstrapped compiler, it is mostly written in NQP. The source code of NQP is in a separate repository at L. Note, NQPx only I the Rakudo compiler, and does not compile or run user programs. =head3 Stages NQP compiles us a compiler in F<../perl6.pbc> and then F<../perl6> or F<../perl6>. NQP also compiles the I found in F. This is a library that controls how classes, methods, roles and so on work. The bare-bones compiler then loads the compiled metamodel, and compiles the I found in F. Those core files provide the runtime library (like the C and C classes). But note that many of these classes are also used when the final compiler processes your Perl 6 scripts. =head2 2. Compiler main program A subroutine called C<'MAIN'>, in F, starts the source parsing and bytecode generation work. It creates a C object for the C<'perl6'> source type. Before tracing Rakudo's execution further, a few words about Parrot process and library initialization. Parrot execution does not simply begin with 'main'. When Parrot executes a bytecode file, it first calls all subroutines in it that are marked with the C<:init> modifier. Rakudo has over 50 such subroutines, brought in by C<.include> directives in F, to create classes and objects in Parrot's memory. Similarly, when the executable loads libraries, Parrot automatically calls subs having the C<:load> modifier. The Rakudo C<:init> subs are usually also C<:load>, so that the same startup sequence occurs whether Rakudo is run as an executable or loaded as a library. So, that Rakudo 'main' subroutine had created a C object. Next, 'main' invokes the C<'command_line'> method on this object, passing the command line arguments in a PMC called C. The C<'command_line'> method is inherited from the C parent class (part of the PCT, remember). And that's it, apart from a C<'!fire_phasers'('END')> and an C. Well, as far a C<'main'> is concerned. The remaining work is divided between PCT, grammar and actions. =head2 3. Grammar Using C, C target C uses F to compile F to F. The compiler works by calling C method in F. After some initialization, TOP matches the user program to the comp_unit (meaning compilation unit) token. That triggers a series of matches to other tokens and rules (two kinds of regex) depending on the source in the user program. For example, here's the parse rule for Rakudo's C statement (in F): token statement_control:sym { :s [ || <.panic: 'unless does not take "else", please rewrite using "if"'> ] } This token says that an C statement consists of the word "unless" (captured into C<< $ >>), and then an expression followed by a block. The C<.panic:> is a typical "Awesome" error message and the syntax is almost exactly the same as in F, described below. Remember that for a match, not only must the C<< >> match the word C, the C<< >> must also match the C token. If you read more of F, you will learn that C in turn tries to match an C<< >> and a C<< >>, which in turn tries to match ..... That is why this parsing algorithm is called Recursive Descent. The top-level portion of the grammar is written using Perl 6 rules (Synopsis 5) and is based on the STD.pm grammar in the C repository (L). There are a few places where Rakudo's grammar deviates from STD.pm, but the ultimate goal is for the two to converge. Rakudo's grammar inherits from PCT's C, which provides the C<< <.panic> >> rule to throw exceptions for syntax errors. =head2 4. Actions The F file defines the code that the compiler generates when it matches each token or rule. The output is a tree hierarchy of objects representing language syntax elements, such as a statement. The tree is called a Parrot Abstract Syntax Tree (PAST). The C class inherits from C, another part of the Parrot Compiler Toolkit. Look in F<../parrot/ext/nqp-rx/stage0/src/HLL-s0.pir> for several instances of C<.namespace ["HLL";"Actions"]>. When the PCT calls the C<'parse'> method on a grammar, it passes not only the program source code, but also a pointer to a parseactions class such as our compiled C. Then, each time the parser matches a named regex in the grammar, it automatically invokes the same named method in the actions class. Back to the C example, here's the action method for the C statement (from F): method statement_control:sym($/) { my $past := xblock_immediate( $.ast ); $past.pasttype('unless'); make $past; } When the parser invokes this action method, the current match object containing the parsed statement is passed into the method as C<$/>. In Perl 6, this means that the expression C<< $ >> refers to whatever the parser matched to the C token. Similarly there are C<< $ >> and C<< $ >> objects etc until the end of the recursive descent. By the way, C<< $ >> is Perl 6 syntactic sugar for C< $/{'xblock'} >. The magic occurs in the C<< $.ast >> and C expressions in the method body. The C<.ast> method retrieves the PAST made already for the C subtree. Thus C<$past> becomes a node object describing code to conditionally execute the block in the subtree. The C statement at the end of the method sets the newly created C node as the PAST representation of the unless statement that was just parsed. The Parrot Compiler Toolkit provides a wide variety of PAST node types for representing the various components of a HLL program -- for more details about the available node types, see PDD 26 ( L ). The PAST representation is the final stage of processing in Rakudo itself, and is given to Parrot directly. Parrot does the remainder of the work translating from PAST to PIR and then to bytecode. =head2 5. Parrot extensions Rakudo extends the Parrot virtual machine dynamically (i.e. at run time), adding 14 dynamic opcodes ("dynops") which are additional virtual machine code instructions, and 9 dynamic PMCs ("dynpmcs") (PolyMorphic Container, remember?) which are are Parrot's equivalent of class definitions. The dynops source is in F, which looks like C, apart from some Perlish syntactic sugar. A F<../parrot_install/bin/ops2c> desugars that to F which your C compiler turns into a library. For this overview, the opcode names and parameters might give a vague idea what they're about: rakudo_dynop_setup() rebless_subclass(in PMC, in PMC) find_lex_skip_current(out PMC, in STR) x_is_uprop(out INT, in STR, in STR, in INT) get_next_candidate_info(out PMC, out PMC, out PMC) transform_to_p6opaque(inout PMC) deobjectref(out PMC, in PMC) descalarref(out PMC, in PMC) allocate_signature(out PMC, in INT) get_signature_size(out INT, in PMC) set_signature_elem(in PMC, in INT, in STR, in INT, inout PMC, inout PMC, inout PMC, inout PMC, inout PMC, inout PMC, in STR) get_signature_elem(in PMC, in INT, out STR, out INT, out PMC, out PMC, out PMC, out PMC, out PMC, out PMC, out STR) bind_signature(in PMC) x_setprophash(in PMC, in PMC) The dynamic PMCs are in F, one file per class. The language is again almost C, but with other sugary differences this time, for example definitions like C whose purpose will appear shortly. A F<../parrot_install/lib/x.y.z-devel/tools/build/pmc2c.pl> converts the sugar to something your C compiler understands. For a rough idea what these classes are for, here are the names: P6Invocation P6LowLevelSig MutableVAR Perl6Scalar ObjectRef P6role Perl6MultiSub Perl6Str and P6Opaque. =head3 Binder The dynops and the dynpmcs call a utility routine called a signature binder, via a function pointer called C. A binder matches parameters passed by callers of subs, methods and other code blocks, to the lexical names used internally. Parrot has a flexible set of calling conventions, but the Perl 6 permutations of arity, multiple dispatch, positional and named parameters, with constraints, defaults, flattening and slurping needs a higher level of operation. The answer lies in F which is compiled into C and C libraries. Read L for a more detailed explanation of the binder. F has three C<.loadlib> commands early on. The C loads the 9 PMCs, the C does the 14 dynops, and the C adds over 30 mathematical operators such as C, C, C, C
, C, C, C, C etc. (source in F) =head2 6. Builtin functions and runtime support The last component of the compiler are the various builtin functions and libraries that a Perl 6 program expects to have available when it is running. These include functions for the basic operations (C<< infix:<+> >>, C<< prefix: >>) as well as common global functions such as C and C. The stage-1 compiler compiles these all and they become part of the final F. The source code is in F, F, F, F and F. =head2 Still to be documented * Rakudo PMCs * The relationship between Parrot classes and Rakudo classes * Protoobject implementation and basic class hierarchy =head1 AUTHORS Patrick Michaud is the primary author and maintainer of Rakudo. The other contributors and named in F. =head1 COPYRIGHT Copyright (C) 2007-2010, The Perl Foundation. =cut # Local Variables: # fill-column: 100 # End: # vim: expandtab shiftwidth=4: rakudo-2015.11/docs/deprecations000644 000765 000024 00000006315 12573545401 020467 0ustar00williamcoledastaff000000 000000 Deprecations in 2013.12 eval is now spelled EVAL Deprecations in 2013.11 Order::Increase and Order::Decrease are now called Order::Less and Order::More. Using "Increase" or "Decrease" will now generate "is DEPRECATED" warnings at the end of execution. Deprecations in 2012.12 'for'-loops will be lazy (just like map), and only be automatically run in sink (void) or list context. This causes problems if the last statement in a block is a for-loop that either calls return(), or is inside a try { } block. Since such code is now run after the block exits, it is not in the dynamic scope of the routine or the try block. As a fix, you can force eager execution of the for-loop by adding another statement after it, or by writing 'eager do for LIST BLOCK'. This change will take effect in 2013.01. Warnings will start being issued for unused parameters to pointy blocks and routines. At present, they do not warn at all. Planned for 2013.01. Constructs like "my $a; { $a; my $a; }", where the meaning of the first mention of $a in the block would create confusion as to what was being referred to, will become an error as in STD. This change will take effect in 2013.01. Deprecations in 2012.11 At present, a reference to an &foo that does not exist evaluates to Nil. This will become a CHECK-time failure, in line with STD. Planned for the 2012.12 release. Deprecations in 2012.10 Protos for built-in routines are now mostly as generic as possible, and will be changed to be specific to the arity of the routine. For example 'proto sub chr(|) {*}' will become 'proto sub chr($) {*}' This affects everybody who adds multis with unusual arity to built-in subs. Planned for the 2012.11 release. Unary hyper ops currently descend into nested arrays and hashes. This will change to make them equivalent to a one-level map. Planned for the 2012.11 release. ~/.perl6/lib will go away from the default include path (@*INC). Instead %*CUSTOM_LIB now holds paths to four library locations: perl Rakudo installs its core modules here vendor OS-level package managers should install their modules here site for local module installations (e.g. with panda or ufo) home like site, but always under the user's home directory. fallback if site isn't writable. Removal of ~/.perl6/lib from @*INC planned for the 2012.11 release Deprecations in 2012.09 Str.capitalize and &capitalize are deprecated in favor of the Str.wordcase and &wordcase routines. They will uncondtionally warn in 2012.10, and be removed in 2012.11. Deprecations in 2012.08 Parameters preceded by a | or \ may not have a sigil anymore. sub f(\$x) { say $x } must be changed to sub f(\x) { say x } Usage of \$x will unconditionally warn in 2012.09 and be removed in 2012.10 IO::Path.dir (which returns the directory part of the path) has been renamed to IO::Path.directory. IO::Path.dir will be removed or re-purposed in 2012.09 The LAZY statement prefix will be removed in 2012.09. It was a non-specced experiment and did not work out well. rakudo-2015.11/docs/glossary.pod000644 000765 000024 00000003434 12573545401 020432 0ustar00williamcoledastaff000000 000000 ## $Id$ =head1 glossary.pod - glossary of terms used in the Rakudo compiler =over =item action method Action methods are typically used to perform transformations and other actions while parsing a source code program. Parse grammars typically use the special token C< {*} > to indicate the point at which an action method is to be invoked. In addition, a line containing C< {*} > may also use C< #= > to specify a "key" that is to be passed to the action method. =item NQP - Not Quite Perl NQP is a primitive language for writing subroutines and methods using a subset of the Perl 6 syntax. It's not intended to be a full-fledged programming language, nor does it provide a runtime environment beyond the basic VM primitives. Compilers typically use NQP to compile "action methods" that convert a parse tree into its equivalent abstract syntax tree representation. =item Rakudo Rakudo is the name of a Perl 6 implementation that runs on MoarVM and the JVM. An abbreviation of "Rakuda-do," which, when translated from Japanese, means "The Way of the Camel". In Japanese, "Rakudo" means "Paradise." For more info, see L. =item STD.pm STD.pm is the "standard" Perl 6 grammar definition, see L. At the moment STD.pm is not really a "specification" in a proscriptive sense -- it's more of a guideline or model for Perl 6 implementations to follow. The goal is that eventually the various implementations will converge on a common grammar (that will probably look a lot like STD.pm). =back =cut =head1 AUTHORS Patrick Michaud is the primary author and maintainer. =head1 COPYRIGHT Copyright (C) 2007, The Perl Foundation. =cut # Local Variables: # fill-column: 100 # End: # vim: expandtab shiftwidth=4: rakudo-2015.11/docs/guide_to_setting.pod000644 000765 000024 00000004042 12573545401 022117 0ustar00williamcoledastaff000000 000000 =encoding utf-8 =head1 NAME Guide to the C setting. =head1 DESCRIPTION Notes about writing code to go in Rakudo's setting. =over 4 =item Think of laziness Avoid anything that forces eager evaluation of arrays, like querying their length. This is bad: while $i < self.elems { ... } Better use a C loop, which will respect laziness for self.list { ... } If you assemble multiple items into a potentially lazy list, C is a very good construct to remember. =item Take care with type constraints Some of the Synopsis documents list type constraints for some of the arguments, including the invocant. They are not always correct, when in doubt leave them out. =item When adding a new file in src/core/ ... remember to add it to L to the C variable and re-generate the Makefile using L. =item Prefer C to explicit invocant variables. Many of the method specifications in the synopses list explicit invocant variables. Using them often makes the code less clear, and can sometimes be incorrect (for example, an invocant of C<@values> will restrict the method to invocants that have the C role). Better is to use C, or if invoking a method on C then you can use C<$.foo> or C<@.bar> directly. =item All subs and methods are really multis All built-in methods or subroutines should be declared as C. =item Use explicit empty signatures If a method doesn't take any arguments, give it an explicit empty signature C<()>. That's very different from omitting the signature altogether (which would be an implicit catch-all signature). =item Use implicit return at the end of routines If no C statement is executed in a routine, the value of the last evaluated expression is returned. So if a C is the last statement in a routine, omit the C - currently explicit returns take much more time than implicit ones. =back =head1 SEE ALSO L =for editor vim: ft=pod tw=70 rakudo-2015.11/docs/metamodel.pod000644 000765 000024 00000032072 12573545401 020536 0ustar00williamcoledastaff000000 000000 =head1 The Rakudo Metamodel =head2 Warning What follows is the current way this works in Rakudo. Parts of it may one day become spec, other bits likely never will. All of it is liable to change as we work out what should be spec and what shouldn't be, and also co-ordinate with other implementations and interested parties to make sure those bits that we determine should be specification are spec'd in a way that matches our shared desires and needs, so far as that's possible. It goes without saying that in doing the things described in this document, you're walking barefoot through a construction site. For now, tread carefully, and be prepared to patch up in response to changes. =head2 Overview Meta-objects are simply objects that describe parts of the object model. The metamodel lays down the interface that these objects should provide. In Rakudo we have several types of meta-object, all of which have an associated API (sometimes known as a Meta-object Protocol, just to make sure the whole topic appears to be sufficiently scary to outsiders, or something). This document defines the API for: =over 4 =item Packages meta-objects (representing classes, grammars, roles, etc); ones included in Rakudo include ClassHOW, GrammarHOW and RoleHOW. =item Attribute meta-objects (representing attributes); the default one of these is simply called Attribute. =item Composition meta-objects (e.g. specifying role composition algorithms) =back The composition model warrants a little explanation, since it is broken into a couple of parts. We'll stick with classes and roles for now, but we define the interface in the expectation that one day we might want to have things that are composed into a class following some composition algorithm that may be given a different name. Thus we talk in terms of "composables". There are two important things. First, the actual composer - implementing the composition algorithm - is not a part of the thing we're composing or the thing we're composing into (that is, it is independent of the class and the role). Second, it is up to the thing being composed (e.g. the role in the case of composing a role into a class) to supply the composer. =head2 Package meta-object API (aka HOW API) This is the API for packages. When we compile something like: class Town is Place { method bar() { say "mmm beer" } } Then it results in a set of calls like: my $temp = ClassHOW.new('Town'); &trait_mod:($temp, Place); $temp.^add_method('bar', anon method bar() { say "mmm beer" }); ::Town := $temp.^compose(); Most of these are calls on the meta-class to methods that give meaning to the keywords the user wrote in their code. The following methods are supported as a minimum. =over 4 =item method new($name?) Creates something that knows how to provide its metaclass, e.g. through the same mechanism as C<.HOW> obtains it. It need not be the final type-object that may be installed in a namespace or lexpad - that is for compose to return. However, there's nothing to stop it being. Whether a new instance of the meta-class is created or not is totally up to the implementation of the C method. For the standard Perl 6 C keyword in Rakudo, we create an instance of the meta-class and a temporary object that only knows how to reference the meta-class instance. However, if you were doing a more prototype-OO implementation, then you could instead have the meta-class be a singleton and return a new object, and the object itself knows completely about its methods, attributes and so forth, rather than this knowledge belonging to the meta-class. =item add_method($meta, $name, &code_ref) Adds a method to the methods table of C<$meta> under the given C<$name> and with the given implementation. =item add_attribute($meta, $name) Adds an attribute of the given C<$name> to C<$meta>. =item add_parent($meta, $parent) Adds the given parent to C<$meta>. =item add_composable($meta, $composee) Takes something that we are able to compose (for example, a role) and adds it to the composition list. Certainly, none of the built-in implementations of add_composable immediately perform any composition at this point. Instead, they add the composable to a "to do" list, and at the point we call "compose" to finish the composition of the package, and the application of all the composables takes place. You probably want to do something similar. =item applier_for($meta, $target) For non-composables (that is, packages that cannot be composed into others), this is an error. Otherwise, it returns something that we can use to apply the current package to the target. The thing returned should implement the composer API. It may be convenient to implement this is a set of multi subs. =item compose($meta) Finalizes the creation of the package. It can do any other composition-time operations, such as role composition and calling the composition hook on all attributes added to the package. Returns the type object that we're going to actually install into the namespace or lexical pad, or just return if it's an anonymous declaration. =back This is the declarational part of the API, however the introspection part should also be implemented. Please see the Introspection section of S12 for details on this. =head2 Attribute meta-object API This is the API that objects representing attributes should expose. The attribute meta-object is responsible for generating any accessor and/or delegation methods associated with the attribute. =over 4 =item new($name, :$has-accessor, :$rw, :$handles, :$build, :$type) Creates a new attribute meta-object, initialized with the name, whether or not the attribute has an accessor, whether or not that accessor 'is rw' and - if there was a handles trait modifier on the attribute - the handles trait modifier. =item compose($meta-package) Takes the attribute and does any final composition tasks (such as installing any accessor methods and/or delegators). The parameter is the meta-object of the package that the attribute belongs to; you can call .add_method on it to add methods, for example. =back =head2 Composer meta-object API The composer is responsible for composing something composable (in standard Perl 6, that's a role) into some other object (perhaps a class or another role or an instance). The minimal interface need only support one method, but it may well be that a composee and a composer choose to share knowledge of more than this (for example, a "requires" or "conflicts" list). =over 4 =item apply($target, @composees) Applies all of the composees to the target, or throws an exception if there is a problem with doing so. It's totally up to the composer exactly what it does; the default composer for Perl 6 roles will construct a single intermediate role and then compose that into the target, for example. Since the model is intended for more general composition-y things rather than just roles as are commonly defined today, we choose to give the composer a view of all of the composees. =back =head2 Metaclass Compatibility Warning: Conjectural. One rather complex issue we run into is what happens if you want to inherit from something that has a different metaclass. For now, we require that if some class S isa T, then also S.HOW isa T.HOW. This means that all other types of class-ish things that want to have a custom metaclass should subclass ClassHOW (either directly or transitively). Thus, this is fine: class A { } thingy B is A { } otherthingy C is B { } If the following is true: OtherThingyHOW.isa(ThingyHOW) and ThingyHOW.isa(ClassHOW) =head2 Composer Compatibility Warning: Conjectural. TODO: Provide a solution to the problems described here. Given it's the things we compose that determine what composer to use, we may easily run into a situation where different things want a different composer. At some level that's OK - if we want to support a more general notion of "things that do something composition-ish" then it is probably too restrictive to just always make this an error in the long run. For now, however, we do just that; when we have a good solution, we can relax the restriction. We do have the nicety that once we hit runtime, since composition is flattening by nature, we don't have any relationship at runtime with something that was composed in (besides keeping it in our list of "things that we composed"). Thus the problem of the behaviors of two different appliers is only a composition-time issue and not a runtime one. =head2 Associating a package declarator with a metaclass Rakudo provides two levels of hookage for creating new types of package declarator. You will very likely only need this one, which is the HOW map, %*HOW. This is simply a hash that maps the name of a scope declarator to the name of the HOW to create. At the entry point to your derived grammar, you should temporize the current HOW hash from the calling language, and add mappings from names of package declarators that you will introduce to the HOW to use. By default, this hash contains things like: { class => 'ClassHOW', role => 'RoleHOW' } It's completely fine for multiple package declarators to map to the same HOW - you may just wish to introduce a new one as better documentation but not need to do anything more special in terms of the meta-model. Note that your rule for parsing the scope declarator sets the name of the thing in this map in the $*PKGDECL global. For example, here is one from STD. token package_declarator:role { :my $*PKGDECL ::= 'role'; } You should do the same (and it's probably nice if what you set matches the name of the symbol you parse). =head2 Meta-programming Example: Adding AOP Support Note that this currently does not work in Rakudo, and will probably change a bit. It's purpose is mostly a thought experiment to try and help sanify the design of the metamodel. slang AOP { method TOP { temp %*HOW; %*HOW := AspectHOW; my $lang = self.cursor_fresh( AOP ); $lang.comp_unit; } token package_declarator:sym { :my $*PKGDECL := 'aspect'; } } class AspectComposer { method apply($target, @aspects) { my @wrappables = $target.methods(:local); for @aspects -> $aspect { for $aspect.method_wrappers.kv -> $name, $wrapper { my ($wrappee) = @wrappables.grep({ .name eq $name }); if $wrappee { $wrappee.wrap($wrapper); } else { die "No sub found to wrap named '$name'"; } } } } } class Aspect { has $.HOW; has $.Str; method WHAT() { self } method defined() { False } } class AspectHOW { has %.method_wrappers; method new($name) { return Aspect.new( HOW => self.bless(*), Str => $name ~ "()" ); } method add_method($obj, $name, $method) { $.method_wrappers{$name} = $method; } multi method composer_for($obj, $ where { .can('methods') }) { return AspectComposer; } multi method composer_for($obj, Object) { die "Can only apply aspects to things that expose methods"; } method compose($obj) { return $obj; } method add_attribute($meta, $attr) { die "Aspects do not support attributes"; } method add_parent($meta, $parent) { die "Aspects do not support inheritance"; } method add_composable($meta, $composable) { die "Aspects do not support being composed into"; } } This could then we used as something like: use AOP; aspect LogToStderrToo { method log($message) { $*ERR.say($message); nextsame; } } class ErrorLog does LogToStderrToo { method log($message) { my $fh = open("log", :a); $fh.say($message); $fh.close; } } Note that a usable implementation would want a bit more than this, and have many other design considerations. =head2 Influencing package code generation Note: This is highly Rakudo-specific and very likely to remain that way. The good news is that you won't need to do it often. Rakudo has a compile-time representation of the package currently being compiled. This is the thing that ends up actually generating the code - PAST nodes - that make the calls on the metaclass. By default, we always create an instance of Perl6::Compiler::Package, apart from for roles and modules, for which we need to do some slightly different code generation - those use a subclass of it, such as Perl6::Compiler::Role. You may modify %*PKGCOMPILER, again keying on $*PKGDECL, to specify something other than the default. You should then write a subclass of an existing handler for this and implement the same interface (plus any other bits you'll need - it's just a class). rakudo-2015.11/docs/metaobject-api.pod000644 000765 000024 00000006064 12573545401 021455 0ustar00williamcoledastaff000000 000000 =head1 Rakudo Meta-Object API This document describes the meta-objects that constitute Rakudo's objects implementation. It also describes the API to implement should you wish to introduce your own meta-objects. =head2 Meta-model Organization Rakudo is built on top of the NQP platform. NQP provides an object model core that is often known as "6model". It is inspired by the needs of Perl 6, but actually provides a very minimal base that other languages can build their own meta-objects on top of. While Rakudo could start from these base primitives, instead it makes use of some of the NQP meta-objects. Out of the box 6model provides no concept of classes or roles. NQP's meta-objects include a simple, non-parametric implementation of roles and a simple but capable implementation of classes. These are put to use in writing Rakudo's meta-objects. The Rakudo meta-objects are generally factored in terms of roles. These are composed into classes that represent the various types of Perl 6 package (such as classes and roles). =head2 Roles The following roles exist and provide re-usable pieces of functionality that can be re-used in various places in the meta-model. =head3 MethodContainer This role provides storage of methods, method addition and method introspection. =head3 MultiMethodContainer This role provides the extra pieces needed for multi-method handling. =head3 AttributeContainer This role provides storage of attributes, attribute addition and attribute introspection. =head3 RoleContainer This role provides storage of roles, role addition and role introspection. The composition process is not part of the functionality provided by this role, however. =head3 MultipleInheritance Provides for addition of multiple parents, and introspection of them too. =head3 C3MRO This role provides an implementation of the C3 method resolution order. =head3 Versioning This role provides storage and introspection of a version and authority. =head2 Classes The following classes exist in the Perl 6 meta-model. =head3 ModuleHOW Provides an implementation of modules. =head3 ClassHOW Provides an implementation of classes. =head3 ParametricRoleHOW Provides an implementation of parametric roles, which may be instantiated. =head3 ConcreteRoleHOW Provides an implementation of a concrete instance of a role. =head3 GrammarHOW Provides an implementation of grammars. Actually, just a subclass of the ClassHOW since grammars are really just slightly specialized classes. =head3 NativeHOW Meta-object for a native type (only accessible via the type object, perhaps). =head3 SubsetHOW Provides an implementation of subset types. =head3 Attribute Represents an attribute. =head3 RoleToClassComposer Composes a single role into a class. (If many roles are specified, it makes a single role that does all of the roles the class wishes to, and then composes that single role). =head3 RoleToRoleComposer Composes one or more roles into another role, creating a kind of role "summation". =head3 RoleToObjectComposer Composes a role into an object - essentially doing a mix-in. rakudo-2015.11/docs/obtaining-a-commit-bit.pod000644 000765 000024 00000004321 12573545401 023015 0ustar00williamcoledastaff000000 000000 =head1 How to obtain a commit bit for the Rakudo repository? Firstly, what's a "commit bit"? If you don't know what it is, you probably don't need one :-) But, in any case, a "commit bit" is the colloquial way that #perl6 describes how you obtain access to make commits directly to the rakudo repository. (i.e., not via a fork and pull request, but directly to https://github.com/rakudo/rakudo) Step one, if you haven't already, is to send a signed copy of the Contributor License Agreement (CLA) to the Perl Foundation. The CLA can be found at http://www.perlfoundation.org/contributor_license_agreement Why is a signed CLA necessary for commit access? Historically, it is because Rakudo used to be part of the Parrot project and that project required a signed CLA. But the reasons that Parrot required a CLA are also valid for Rakudo. That is, the CLA helps protect the Perl Foundation and the Rakudo project and contributors alike from intellectual property issues. The CLA warrants that your contributions are yours to give and that they are not encumbered by anyone else's intellectual "lien" on those contributions. For instance, some employment contracts stipulate that any intellectual property that you generate belongs to your employer whether you generate it during work or after hours at home or while on vacation. If your employment contract has such a stipulation, you must seek permission from your employer such that you can contribute to Rakudo without fear that your employer will later claim ownership of your contributions. The CLA says that you have done the due diligence in these matters and that as far as you are aware, your contributions are yours alone to give. Once you send off your signed CLA, you can then inquire on irc://freenode.net/#perl6 about getting commit access to the Rakudo repository. The main source code repository for Rakudo is administered on GitHub, so it would be a good idea to have a github account before you request a commit bit. There is at least one officer of the Perl Foundation on #perl6 who can verify the reception of your signed CLA and several people that can then add you to the Rakudo project. Typically a commit bit is granted after a new contributor has submitted a few good patches. rakudo-2015.11/docs/release_guide.pod000644 000765 000024 00000031065 12623477247 021375 0ustar00williamcoledastaff000000 000000 =encoding UTF-8 =head1 release_guide.pod - guide to Rakudo releases Rakudo’s development release cycle is the Thursday following the third Tuesday of each month (This historically allowed Rakudo to follow Parrot’s release cycle). Each development release is given a sequential number and a code name based on an active Perl Mongers group. For releases made so far, see the list of development releases at the end of this document. =head2 Planned future releases 2015-12-17 Rakudo #94 (Coke) # v6.c (More planned dates can be generated with F). =head2 Suggested .pm group names for future releases Names can be gotten from L if you can’t think of one with any particular significance to Perl 6 or Rakudo. There is a rudimentary tool for discerning available Perl Monger group names that have not already been used for a release in F =head2 Steps to create a release (for release managers) =over 4 =item 1. A few days before the Rakudo release, it’s a good idea to... =over 4 =item * Remind people of the upcoming release, invite people to update the ChangeLog file, update the ROADMAP, choose a release name, etc. =item * Check if any DEPRECATED code needs to be removed because the end of the deprecation cycle is reached. One way of doing this, is to grep on the YYYYMM of the release (e.g. 201412 for the 2014.12 release). If you find any occurrences, remove the code and make sure the spectest is still ok. =item * Review the RT queue for tickets that might need resolving prior to the release, addressing them as needed. “Tickets that need resolving” is left your discretion. Any problem that has a large impact on users is worth addressing either as a fix or as prominent documentation (the README and/or the release announcement). =item * Create a draft release announcement in docs/announce/YYYY.MM.md in markdown format. You can often use the previous release’s file as a starting point, updating the release number, version information, name, etc. as appropriate. $ git add docs/announce/YYYY.MM.md $ git commit docs =item * If it’s a month relatively early in the calendar year, double-check that the copyright date in the README file includes the current year. (It’s not necessary to update copyright dates in other files, unless you know that a given file has been modified in a year not reflected by the file’s copyright notice.) =back =item 2. Update Rakudo’s leap-second tables: $ perl tools/update-tai-utc.pl src/core/tai-utc.pm If a new leap second has been announced, F will be modified, so commit the new version: $ git commit src/core/tai-utc.pm But probably there won’t be any new leap seconds, in which case the file will be unchanged. B: this program requires the perl modules L, L and L to be installed. =item 3. As the actual release date nears, review the git log history to see if any additional items need to be added to the ChangeLog. This can be conveniently done with $ git log --since=yyyy-mm-dd --reverse # find commits # update ChangeLog $ git commit docs/ChangeLog # commit changes =item 4. When it’s time to cut the release, finalize the new release announcement in docs/announce/YYYY.MM.md . (If one hasn’t already been created, see step 1 above.) Highlight areas in which the new release is significant. If possible, also give some small details about the choice of release name. (If the details are a bit lengthy, this can often best be done as a separate section at the bottom of the announcement.) Include a list of contributors since the last release in the announcement. You can get an automatically generated list by running $ perl6 tools/contributors.pl6 Please check the result manually for duplicates and other errors. $ git add docs/announce/YYYY.MM.md $ git commit docs =item 5. Update the release dates and names at the bottom of this file (F). Also improve these instructions if you find any steps that are missing. $ git commit docs/release_guide.pod =item 6. Create an NQP release with the same C version number as Rakudo. Follow NQP’s C file to do that. =item 7. Go back to the Rakudo repository, and update the NQP dependency: $ echo YYYY.MM > tools/build/NQP_REVISION $ git commit -m '[release] bump NQP revision' tools/build/NQP_REVISION =item 8. Enter the new version into the F file, and commit the changes: $ echo YYYY.MM > VERSION $ git commit -m '[release] bump VERSION' VERSION =item 9. Make sure any locally modified files have been pushed back to github. $ git status $ git push =item 10. Make sure everything compiles and runs from a known clean state: $ make realclean $ perl Configure.pl --gen-moar --backends=ALL $ make $ make test $ make stresstest There are many tests to run for the stresstest target. If you have a machine with multiple CPU cores, you may want to execute that last as $ TEST_JOBS=4 make stresstest where 4 is the number of CPU cores. This should make the total time to execute all of the tests dramatically less. Continue adjusting things until make stresstest passes as expected. Often this means fixing a bug, fudging a test, or (temporarily?) commenting out a test file in t/spectest.data . Use your best judgment or ask others if uncertain what to do here. =item 11. Create a tarball by entering C, where YYYY.MM is the month for which the release is being made. This will create a tarball file named C. B: this step removes any untracked files in F. So please make a backup if you have any important data in there. =item 12. Unpack the tar file into another area, and test that it builds and runs properly using the same process in step 10. If there are any problems, fix them and go back to step 10. =item 13. Tag the release by its release month ("YYYY.MM") and its code name. $ git tag -s -a -m"tag release #nn" YYYY.MM # e.g., 2013.08 $ git tag -s -a -m"tag release #nn" CODENAME # e.g., "Bratislava" If this is a new non-dev $*PERL.version, tag with the version as well. $ git tag -s -a -m"tag release #nn" VERSION # e.g., v6.b Push all tags. $ git push --tags The C<-s> tells git to sign the release with your PGP/GPG key, so it will likely ask you for the passphrase of your secret key. If you have no PGP key, you might need to L. Should that prove impossible, you can omit the C<-s> from the command line. =item 14. Sign the tarball with your PGP key: $ gpg -b --armor rakudo-YYYY-MM.tar.gz =item 15. Upload the tarball and the signature to L: $ scp rakudo-YYYY.MM.tar.gz rakudo-YYY-MM.tar.gz.asc \ rakudo@rakudo.org:public_html/downloads/rakudo/ If you do not have permissions for that, ask one of (pmichaud, jnthn, FROGGS, masak, tadzik, moritz, PerlJam, [Coke], lizmat, timotimo, fsergot)) on #perl6 to do it for you. =item 16. To avoid public confusion with Rakudo Star releases, we now publish compiler release announcements ONLY to perl6-compiler@perl.org. (We may restart widespread announcements of compiler releases once they are known, or we may begin publishing a single announcement for both.) Don’t send out any announcements until the files are actually available per step 14 above. =item 17. Update the Wikipedia entry at L. =item 18. You’re done! Celebrate with the appropriate amount of fun. =back =head2 Development releases so far Previous releases were bundled as part of monthly Parrot releases. 2009-02-26 Rakudo #14 "Vienna" (pmichaud) 2009-03-20 Rakudo #15 "Oslo" (pmichaud) 2009-04-23 Rakudo #16 "Bratislava" (pmichaud) 2009-05-21 Rakudo #17 "Stockholm" (pmichaud) 2009-06-18 Rakudo #18 "Pittsburgh" (pmichaud) 2009-07-23 Rakudo #19 "Chicago" (moritz) 2009-08-20 Rakudo #20 "PDX" (kyle) 2009-09-17 Rakudo #21 "Seattle" (particle) 2009-10-22 Rakudo #22 "Thousand Oaks" (duff) 2009-11-19 Rakudo #23 "Lisbon" (masak) 2009-12-17 Rakudo #24 "Seoul" (chromatic) 2010-01-22 Rakudo #25 "Minneapolis" (pmichaud) 2010-02-18 Rakudo #26 "Amsterdam" (mberends) 2010-03-18 Rakudo #27 "Copenhagen" (smash) 2010-04-22 Rakudo #28 "Moscow" (moritz) 2010-05-20 Rakudo #29 "Erlangen" (colomon) 2010-06-17 Rakudo #30 "Kiev" (masak) 2010-07-22 Rakudo #31 "Atlanta" (Coke) 2010-08-19 Rakudo #32 "Pisa" (mathw) 2010-09-23 Rakudo #33 "Milan" (moritz) 2010-10-21 Rakudo #34 "Paris" (duff) 2010-11-18 Rakudo #35 "Melbourne" (masak) 2010-12-23 Rakudo #36 "New York" (smash) 2011-01-20 Rakudo #37 "BristolBath" (tadzik) 2011-02-17 Rakudo #38 "Toulouse" (arnsholt) 2011-03-17 Rakudo #39 "Orlando" (jdhore) 2011-04-21 Rakudo #40 "ZA" (duff) 2011-05-19 Rakudo #41 "Dahut" (jdhore) 2011-06-23 Rakudo #42 "Bruxelles" (jdhore) 2011-07-21 Rakudo #43 "Beijing" (mberends,moritz) 2011-08-18 -- none -- 2011-09-30 Rakudo #44 "Riga" (tadzik) 2011-10-20 Rakudo #45 "Houston" (duff) 2011-11-17 Rakudo #46 "London" (tadzik) 2011-12-22 Rakudo #47 "Columbus" (moritz) 2012-01-23 Rakudo #48 "Toronto" (moritz) 2012-02-23 Rakudo #49 "SPb" (masak) 2012-03-22 Rakudo #50 "Argentina" (masak) 2012-04-19 Rakudo #51 "Brazos Valley" (Coke) 2012-04-25 2012.04.1 (moritz) 2012-05-17 Rakudo #52 "MadMongers" (tadzik) 2012-06-21 Rakudo #53 "Strasbourg" (duff) 2012-07-19 Rakudo #54 "Tallinn" (masak) 2012-08-23 Rakudo #55 "Frankfurt" (tadzik,moritz) 2012-09-20 Rakudo #56 "Perl" (masak) 2012-09-29 2012.09.1 (pmichaud) 2012-10-18 Rakudo #57 "Tokyo" (duff) 2012-11-22 Rakudo #58 "Walnut" (FROGGS) 2012-12-20 Rakudo #59 "Warszawa" (masak) 2013-01-17 Rakudo #60 "Sonoma" (isBEKaml) 2013-02-21 Rakudo #61 "drinkers" (tadzik) 2013-02-23 2013.02.1 (moritz) 2013-03-21 Rakudo #62 "Singapore" (masak) 2013-04-18 Rakudo #63 "Albany" (Coke) 2013-05-23 Rakudo #64 "Austin" (FROGGS) 2013-06-20 Rakudo #65 "Poznan" (masak) 2013-07-18 Rakudo #66 "Edinburgh" (moritz,lizmat) 2013-08-22 Rakudo #67 "Bicycle" (moritz) 2013-09-19 Rakudo #68 "Shanghai" (masak) 2013-10-17 Rakudo #69 "Roederbergweg" (Coke) 2013-11-21 Rakudo #70 "Malmö" (lizmat) 2013-12-19 Rakudo #71 "Advent" (moritz) 2014-01-23 Rakudo #72 "Plano" (masak) 2014-02-20 Rakudo #73 "Karlsruhe" (timotimo) 2014-03-20 Rakudo #74 "Adelaide" (tadzik) 2014-04-17 Rakudo #75 "Echt" (masak) 2014-05-22 Rakudo #76 "Bajor" (FROGGS) 2014-06-19 Rakudo #77 "Gdańsk" (sergot) 2014-07-17 Rakudo #78 "Sofia" (FROGGS) 2014-08-21 Rakudo #79 "Minsk" (Coke) 2014-09-18 Rakudo #80 "HongKong" (masak) 2014-10-23 Rakudo #81 "Linz" (duff) 2014-11-20 Rakudo #82 "Helsinki" (lizmat) 2014-12-18 Rakudo #83 "Cologne" (lizmat) 2014-12-19 2014.12.1 (lizmat) 2015-01-22 Rakudo #84 "Gotanda" (Coke) 2015-02-19 Rakudo #85 "Berlin" (lizmat) 2015-03-19 Rakudo #86 "Cluj" (FROGGS) 2015-04-23 Rakudo #87 "Vladivostok" (masak) 2015-05-21 Rakudo #88 "Dresden" (FROGGS) 2015-06-18 Rakudo #89 "Salt Lake" (hoelzro) 2015-07-24 Rakudo #90 "Prague" (masak) 2015-07-24 2015.07.1 (masak) 2015-07-25 2015.07.2 (moritz) 2015-09-17 Rakudo #91 "Zürich" (Coke) 2015-10-22 Rakudo #92 "Niceville" (Coke) # v6.b 2015-11-19 Rakudo #93 "Bend" (Coke) =head1 COPYRIGHT Copyright (C) 2009-2015, The Perl Foundation. =cut # Local Variables: # fill-column: 100 # End: # vim: expandtab shiftwidth=4: rakudo-2015.11/docs/running.pod000644 000765 000024 00000005525 12600026162 020237 0ustar00williamcoledastaff000000 000000 =head1 NAME perl6 - Rakudo Perl 6 Compiler =head1 SYNOPSIS perl6 [switches] [--] [programfile] [arguments] =head1 DESCRIPTION With no arguments, enters a REPL. With a C<[programfile]> or the C<-e> option, compiles the given program and by default also executes the compiled code. -c check syntax only (runs BEGIN and CHECK blocks) --doc extract documentation and print it as text -e program one line of program, strict is enabled by default -h, --help display this help text -n run program once for each line of input -p same as -n, but also print $_ at the end of lines --target=[stage] specify compilation stage to emit --encoding=[mode] specify string encoding mode --output=[name] specify name of output file -v, --version display version information --stagestats display time spent in the compilation stages --ll-exception display a low level backtrace on errors --profile write profile information as HTML file (MoarVM) --profile-filename=[name] specify an alternate profile output file Note that only boolean single-letter options may be bundled. The supported values for C<--target> are: Target Backend Description ====== ======= =========== parse all a representation of the parse tree ast all an abstract syntax tree (before optimizations) optimize all an abstract syntax tree (after optimizations) mbc MoarVM MoarVM byte code jar JVM JVM archive For C<--profile-filename>, specifying a name ending in C<.json> will write a raw JSON profile dump. The default if this is omitted is C.html>. =head1 List of env vars used in Rakudo =over =item C, C (src/core/Inc.pm) Appends a delimited list of paths to C<@INC>. C is evaluated first. =item C (src/Perl6/ModuleLoader.pm) If set to a non-false value, causes the module loader to print debugging information to standard error. =item C (src/core/Exception.pm) Controls whether to emit ANSI codes for error highlighting. Defaults to true if unset, except on Win32. =item C (src/core/ThreadPoolScheduler.pm) Controls the maximum number of threads used by a thread pool. =item C (src/core/Deprecations.pm) If set, suppresses deprecation warnings. =item C (src/core/Backtrace.pm) Controls stack frame verbosity. =item C (src/core/Backtrace.pm) Controls whether .setting files are included in backtraces. =back =head1 AUTHORS Written by the Rakudo contributors, see the CREDITS file. This manual page was written by Reini Urban, Moritz Lenz and the Rakudo contributors. =cut rakudo-2015.11/docs/spectest-progress.csv000644 000765 000024 00000131153 12573545401 022274 0ustar00williamcoledastaff000000 000000 "date","revision","pass","fail","todo","skip","regr","spec","files" "2008-05-22 00:00",27739,223,0,0,341,564,2905,31 "2008-05-23 00:00",27763,228,0,0,341,569,2905,32 "2008-05-24 00:00",27775,228,0,0,341,569,2915,32 "2008-05-25 00:00",27796,310,0,0,356,666,2915,39 "2008-05-26 00:00",27812,310,0,0,356,666,2915,39 "2008-05-27 00:00",27839,310,0,0,356,666,2956,39 "2008-05-28 00:00",27868,317,0,0,349,666,2964,39 "2008-05-29 00:00",27910,394,4,15,361,774,3011,43 "2008-05-30 00:00",27933,415,0,15,345,775,3012,43 "2008-05-31 00:00",27953,415,0,15,345,775,3014,43 "2008-06-01 00:00",27986,518,0,15,359,892,3014,52 "2008-06-02 00:00",28021,623,0,15,374,1012,3014,55 "2008-06-03 00:00",28042,623,0,15,374,1012,3014,55 "2008-06-04 00:00",28058,624,0,14,374,1012,3014,55 "2008-06-05 00:00",28084,668,0,15,424,1107,3063,58 "2008-06-06 00:00",28127,674,0,14,422,1110,3068,58 "2008-06-07 00:00",28161,682,0,16,441,1139,3068,59 "2008-06-08 00:00",28174,697,0,17,425,1139,3078,59 "2008-06-09 00:00",28192,699,0,15,425,1139,3079,59 "2008-06-10 00:00",28223,699,0,15,425,1139,3079,59 "2008-06-11 00:00",28229,705,0,15,425,1145,3104,59 "2008-06-12 00:00",28248,705,0,15,425,1145,3125,59 "2008-06-13 00:00",28298,707,0,15,426,1148,3129,60 "2008-06-14 00:00",28331,711,0,15,422,1148,3129,60 "2008-06-15 00:00",28372,754,0,15,432,1201,3153,63 "2008-06-16 00:00",28412,779,0,15,432,1226,3189,64 "2008-06-17 00:00",28454,781,0,15,434,1230,3200,64 "2008-06-18 00:00",28506,781,0,15,434,1230,3200,64 "2008-06-19 00:00",28535,781,0,15,434,1230,3405,64 "2008-06-20 00:00",28570,792,0,15,434,1241,3452,65 "2008-06-21 00:00",28591,794,0,15,431,1240,3451,65 "2008-06-22 00:00",28627,843,0,15,391,1249,3494,66 "2008-06-23 00:00",28658,849,0,20,384,1253,3505,66 "2008-06-24 00:00",28672,849,0,20,384,1253,3510,66 "2008-06-25 00:00",28693,891,0,31,389,1311,4218,70 "2008-06-26 00:00",28701,944,0,38,432,1414,4292,73 "2008-06-27 00:00",28737,1080,1,38,310,1429,4311,75 "2008-06-28 00:00",28767,1072,17,38,314,1441,4338,75 "2008-06-29 00:00",28810,1077,74,38,286,1475,4380,75 "2008-06-30 00:00",28840,1126,0,38,307,1471,4484,74 "2008-07-01 00:00",28858,1172,0,36,314,1522,4484,75 "2008-07-02 00:00",28928,1290,0,47,368,1705,4788,80 "2008-07-03 00:00",28991,1365,0,47,418,1830,4814,83 "2008-07-04 00:00",29042,1473,0,56,539,2068,5096,86 "2008-07-05 00:00",29065,1587,0,59,433,2079,5097,87 "2008-07-06 00:00",29090,1587,0,59,433,2079,5115,87 "2008-07-07 00:00",29114,1618,0,84,462,2164,5240,90 "2008-07-08 00:00",29144,1662,0,86,504,2252,5283,94 "2008-07-09 00:00",29181,1677,0,82,498,2257,5288,94 "2008-07-10 00:00",29220,1679,0,85,520,2284,5328,94 "2008-07-11 00:00",29277,1691,0,85,520,2296,5340,95 "2008-07-12 00:00",29323,1691,0,85,520,2296,5340,95 "2008-07-13 00:00",29376,1691,0,85,520,2296,5340,95 "2008-07-14 00:00",29418,1691,0,85,520,2296,5350,95 "2008-07-15 00:00",29468,1695,0,85,516,2296,5350,95 "2008-07-16 00:00",29503,1736,0,81,521,2338,5389,96 "2008-07-17 00:00",29544,1736,0,81,521,2338,5401,96 "2008-07-18 00:00",29575,1770,0,84,529,2383,5429,97 "2008-07-19 00:00",29607,1763,0,87,576,2426,5492,98 "2008-07-20 00:00",29628,1763,0,87,576,2426,5540,98 "2008-07-21 00:00",29642,1763,0,87,576,2426,5555,98 "2008-07-22 00:00",29666,1799,0,94,606,2499,5578,102 "2008-07-23 00:00",29691,1799,0,95,606,2500,5589,102 "2008-07-24 00:00",29719,1815,0,98,606,2519,5610,104 "2008-07-25 00:00",29733,1845,56,103,569,2573,5694,107 "2008-07-26 00:00",29749,1885,0,105,600,2590,5694,110 "2008-07-27 00:00",29786,1896,0,104,599,2599,5703,112 "2008-07-28 00:00",29822,1902,0,103,612,2617,5770,113 "2008-07-29 00:00",29837,1902,0,103,612,2617,5803,113 "2008-07-30 00:00",29869,1861,79,108,583,2631,5845,114 "2008-07-31 00:00",29902,5,2627,0,0,2632,5846,115 "2008-08-01 00:00",29917,1998,3,105,629,2735,5877,116 "2008-08-02 00:00",29933,1998,3,105,629,2735,5877,116 "2008-08-03 00:00",29963,2003,12,105,615,2735,6055,116 "2008-08-04 00:00",29990,2003,12,105,615,2735,6055,116 "2008-08-05 00:00",30019,2102,12,140,827,3081,6055,118 "2008-08-06 00:00",30052,2102,12,140,827,3081,6055,118 "2008-08-07 00:00",30081,2102,12,140,827,3081,6055,118 "2008-08-08 00:00",30120,2198,3,135,869,3205,6065,121 "2008-08-09 00:00",30136,2200,3,135,867,3205,6065,121 "2008-08-10 00:00",30154,2200,3,135,867,3205,6065,121 "2008-08-11 00:00",30161,2196,0,131,878,3205,6065,121 "2008-08-12 00:00",30179,0,3205,0,0,3205,6075,121 "2008-08-13 00:00",30201,2196,0,131,878,3205,6075,121 "2008-08-14 00:00",30217,2196,0,131,878,3205,6075,121 "2008-08-15 00:00",30243,2196,0,131,878,3205,6075,121 "2008-08-16 00:00",30256,2220,0,134,914,3268,6138,121 "2008-08-17 00:00",30275,2220,0,134,914,3268,6170,121 "2008-08-18 00:00",30292,2220,0,134,914,3268,6170,121 "2008-08-19 00:00",30322,2220,0,134,914,3268,6242,121 "2008-08-20 00:00",30370,2249,0,133,938,3320,6235,123 "2008-08-21 00:00",30419,2256,0,248,812,3316,6249,123 "2008-08-22 00:00",30434,2256,0,248,812,3316,6253,123 "2008-08-23 00:00",30465,2263,0,258,814,3335,6278,125 "2008-08-24 00:00",30499,2267,0,258,822,3347,6288,126 "2008-08-25 00:00",30527,2278,0,262,816,3356,6309,127 "2008-08-26 00:00",30556,2278,0,262,816,3356,6309,127 "2008-08-27 00:00",30584,2278,0,262,819,3359,6312,127 "2008-08-28 00:00",30609,2344,0,263,835,3442,6400,131 "2008-08-29 00:00",30631,2351,0,264,840,3455,6413,132 "2008-08-30 00:00",30650,2352,0,263,840,3455,6435,132 "2008-08-31 00:00",30668,2352,0,262,841,3455,6473,132 "2008-09-01 00:00",30680,2389,0,269,850,3508,6473,140 "2008-09-02 00:00",30694,2383,13,269,859,3524,6519,141 "2008-09-03 00:00",30717,2620,49,273,930,3872,6888,150 "2008-09-04 00:00",30745,2707,0,275,945,3927,7066,153 "2008-09-05 00:00",30771,3129,0,386,1278,4793,7246,157 "2008-09-06 00:00",30806,2798,0,281,976,4055,8002,156 "2008-09-07 00:00",30848,3287,0,285,1246,4818,8002,158 "2008-09-08 00:00",30881,3288,0,284,1246,4818,8003,158 "2008-09-09 00:00",30915,3288,0,284,1246,4818,8003,158 "2008-09-10 00:00",30946,3288,0,284,1246,4818,8071,158 "2008-09-11 00:00",30979,3296,0,296,1267,4859,8164,159 "2008-09-12 00:00",31010,3310,0,289,1272,4871,8237,159 "2008-09-13 00:00",31050,3332,4,292,1278,4906,8237,161 "2008-09-14 00:00",31098,3332,4,292,1278,4906,8237,161 "2008-09-15 00:00",31140,3361,0,293,1382,5036,8243,162 "2008-09-16 00:00",31173,3370,0,296,1385,5051,8245,163 "2008-09-17 00:00",31198,3377,0,296,1403,5076,8251,165 "2008-09-18 00:00",31220,3380,4,295,1403,5082,8257,165 "2008-09-19 00:00",31249,3399,0,282,1403,5084,8259,166 "2008-09-20 00:00",31282,3399,0,317,1368,5084,8259,166 "2008-09-21 00:00",31292,3418,0,306,1378,5102,8277,167 "2008-09-22 00:00",31329,3418,0,306,1378,5102,8277,167 "2008-09-23 00:00",31355,3434,0,306,1374,5114,8289,167 "2008-09-24 00:00",31376,3779,0,326,1401,5506,8296,177 "2008-09-25 00:00",31400,3815,0,328,1450,5593,8309,179 "2008-09-26 00:00",31428,3897,0,332,1457,5686,8393,180 "2008-09-27 00:00",31451,4090,0,379,1470,5939,8495,187 "2008-09-28 00:00",31470,4121,0,388,1477,5986,8505,188 "2008-09-29 00:00",31485,4121,0,392,1477,5990,8509,188 "2008-09-30 00:00",31503,4381,0,388,1453,6222,8743,193 "2008-10-01 00:00",31537,4381,7,388,1453,6229,8743,194 "2008-10-02 00:00",31561,4406,0,390,1460,6256,8779,198 "2008-10-03 00:00",31578,4437,0,394,1464,6295,8773,200 "2008-10-04 00:00",31609,4437,0,394,1466,6297,8775,200 "2008-10-05 00:00",31645,4437,0,394,1466,6297,8775,200 "2008-10-06 00:00",31687,4363,74,397,1436,6270,8826,205 "2008-10-07 00:00",31743,4363,74,397,1436,6270,8850,205 "2008-10-08 00:00",31780,4363,74,397,1436,6270,8850,205 "2008-10-09 00:00",31813,4366,11,398,1499,6274,8861,205 "2008-10-10 00:00",31846,4373,0,397,1495,6265,8871,204 "2008-10-11 00:00",31875,4366,0,396,1494,6256,8871,203 "2008-10-12 00:00",31893,4370,0,396,1494,6260,8877,203 "2008-10-13 00:00",31918,4380,0,396,1492,6268,8884,204 "2008-10-14 00:00",31932,4380,0,396,1492,6268,8884,204 "2008-10-15 00:00",31968,4390,0,398,1488,6276,8892,204 "2008-10-16 00:00",31992,4409,0,393,1488,6290,8909,204 "2008-10-17 00:00",32000,4409,0,393,1488,6290,8910,204 "2008-10-18 00:00",32008,4409,0,393,1488,6290,8910,204 "2008-10-19 00:00",32032,4409,0,393,1488,6290,8910,204 "2008-10-20 00:00",32045,4409,0,393,1488,6290,8910,204 "2008-10-21 00:00",32065,4413,0,393,1490,6296,8916,204 "2008-10-22 00:00",32096,4413,0,393,1490,6296,8916,204 "2008-10-23 00:00",32122,4429,0,394,1494,6317,8937,206 "2008-10-24 00:00",32144,4429,0,394,1494,6317,8937,206 "2008-10-25 00:00",32151,4429,0,394,1494,6317,8937,206 "2008-10-26 00:00",32162,4429,0,394,1494,6317,8956,206 "2008-10-27 00:00",32192,4429,2,394,1494,6319,8958,206 "2008-10-28 00:00",32211,4433,2,392,1492,6319,8958,206 "2008-10-29 00:00",32225,4433,2,392,1492,6319,8958,206 "2008-10-30 00:00",32239,4433,0,392,1494,6319,8958,206 "2008-10-31 00:00",32245,4435,0,392,1492,6319,8958,206 "2008-11-01 00:00",32261,4435,0,392,1492,6319,8958,206 "2008-11-02 00:00",32278,4435,0,392,1492,6319,8958,206 "2008-11-03 00:00",32312,4440,0,392,1487,6319,8958,206 "2008-11-04 00:00",32324,4436,5,392,1487,6320,8959,206 "2008-11-05 00:00",32357,4472,10,392,1500,6374,8989,211 "2008-11-06 00:00",32372,4409,0,396,1509,6314,8992,211 "2008-11-07 00:00",32415,4413,0,405,1496,6314,8993,211 "2008-11-08 00:00",32444,4439,4,407,1494,6344,8995,210 "2008-11-09 00:00",32460,4458,7,398,1491,6354,9006,211 "2008-11-10 00:00",32478,4435,58,387,1430,6310,9032,211 "2008-11-11 00:00",32512,4199,473,389,1314,6375,9032,212 "2008-11-12 00:00",32568,4528,8,391,1481,6408,9035,216 "2008-11-13 00:00",32593,4590,0,398,1496,6484,9036,219 "2008-11-14 00:00",32632,4601,0,396,1490,6487,9039,220 "2008-11-15 00:00",32656,4601,0,396,1490,6487,9039,220 "2008-11-16 00:00",32686,4601,0,396,1490,6487,9039,220 "2008-11-17 00:00",32761,4506,41,386,1483,6416,9039,220 "2008-11-18 00:00",32796,4576,41,386,1485,6488,9040,220 "2008-11-19 00:00",32864,4578,41,386,1483,6488,9040,220 "2008-11-20 00:00",32924,4585,41,387,1483,6496,9048,221 "2008-11-21 00:00",32971,4585,41,387,1483,6496,9048,221 "2008-11-22 00:00",32998,4599,41,387,1489,6516,9055,222 "2008-11-23 00:00",33032,4594,41,383,1489,6507,9055,221 "2008-11-24 00:00",33130,4616,41,384,1494,6535,9075,224 "2008-11-25 00:00",33180,4616,41,384,1494,6535,9075,224 "2008-11-26 00:00",33212,4648,41,386,1481,6556,9096,225 "2008-11-27 00:00",33257,5,6347,0,0,6352,9105,227 "2008-11-28 00:00",33295,4634,89,382,1471,6576,9106,227 "2008-11-29 00:00",33322,4653,48,382,1476,6559,9106,227 "2008-11-30 00:00",33359,4653,48,382,1476,6559,9106,227 "2008-12-01 00:00",33411,4689,10,382,1482,6563,9110,227 "2008-12-02 00:00",33436,4689,10,382,1484,6565,9112,227 "2008-12-03 00:00",33449,4689,10,382,1484,6565,9112,227 "2008-12-04 00:00",33477,4703,0,384,1482,6569,9116,227 "2008-12-05 00:00",33499,4710,0,384,1483,6577,9121,228 "2008-12-06 00:00",33539,4708,0,370,1501,6579,9123,228 "2008-12-07 00:00",33590,4717,0,373,1506,6596,9140,231 "2008-12-08 00:00",33645,4779,0,385,1540,6704,9330,233 "2008-12-09 00:00",33696,4805,13,387,1580,6785,9341,236 "2008-12-10 00:00",33741,4884,0,350,1572,6806,9358,235 "2008-12-11 00:00",33793,4916,0,350,1561,6827,9325,235 "2008-12-12 00:00",33823,5004,1,401,1489,6895,9356,240 "2008-12-13 00:00",33823,5005,0,410,1480,6895,9356,240 "2008-12-14 00:00",33844,5005,0,410,1480,6895,9356,240 "2008-12-15 00:00",33898,5101,0,383,1485,6969,9435,249 "2008-12-16 00:00",33949,5139,0,357,1473,6969,9435,249 "2008-12-17 00:00",34009,5170,0,350,1462,6982,9448,250 "2008-12-18 00:00",34055,5213,0,350,1452,7015,9492,250 "2008-12-19 00:00",34059,5213,0,350,1452,7015,9497,250 "2008-12-20 00:00",34114,5228,0,351,1456,7035,9517,252 "2008-12-21 00:00",34185,5645,0,304,1538,7487,9578,261 "2008-12-22 00:00",34232,5790,0,304,1393,7487,9578,261 "2008-12-23 00:00",34267,5833,0,319,1435,7587,9742,264 "2008-12-24 00:00",34313,5837,0,316,1434,7587,9742,264 "2008-12-25 00:00",34346,5840,1,316,1431,7588,9744,264 "2008-12-26 00:00",34364,5880,1,326,1404,7611,9851,264 "2008-12-27 00:00",34407,5905,0,327,1379,7611,9851,264 "2008-12-28 00:00",34465,5913,0,324,1375,7612,9863,264 "2008-12-29 00:00",34549,5802,141,324,1345,7612,9863,264 "2008-12-30 00:00",34615,5912,0,324,1376,7612,9863,264 "2008-12-31 00:00",34686,5911,0,323,1378,7612,9863,264 "2009-01-01 00:00",34735,5911,0,323,1378,7612,9873,264 "2009-01-02 00:00",34787,5911,0,323,1378,7612,10783,264 "2009-01-03 00:00",34854,5911,0,323,1378,7612,10783,264 "2009-01-04 00:00",34911,5911,0,323,1378,7612,10786,264 "2009-01-05 00:00",34959,5914,0,323,1378,7615,10786,265 "2009-01-06 00:00",35013,6170,0,338,1414,7922,11248,279 "2009-01-07 00:00",35093,6171,0,343,1416,7930,11256,279 "2009-01-08 00:00",35189,6175,0,338,1417,7930,11256,279 "2009-01-09 00:00",35243,6172,0,337,1424,7933,11263,279 "2009-01-10 00:00",35329,6141,0,331,1479,7951,11287,279 "2009-01-11 00:00",35386,6143,0,331,1478,7952,11288,279 "2009-01-12 00:00",35432,6218,0,331,1425,7974,11470,281 "2009-01-13 00:00",35477,6233,0,333,1425,7991,11487,282 "2009-01-14 00:00",35517,6233,0,337,1425,7995,11491,282 "2009-01-15 00:00",35576,6254,0,337,1425,8016,11525,284 "2009-01-16 00:00",35615,6263,0,337,1444,8044,11525,285 "2009-01-17 00:00",35664,0,6288,337,1437,8062,11525,286 "2009-01-18 00:00",35708,5,7844,0,0,7849,11525,286 "2009-01-19 00:00",35736,6352,0,313,1458,8123,11542,290 "2009-01-20 00:00",35788,6280,171,297,1420,8167,11582,292 "2009-01-21 00:00",35851,0,8167,0,0,8167,11582,292 "2009-01-22 00:00",35875,6500,11,308,1420,8239,11651,294 "2009-01-23 00:00",35904,6523,0,310,1421,8254,11666,295 "2009-01-24 00:00",35944,6522,0,307,1435,8264,11676,295 "2009-01-25 00:00",35983,6383,180,292,1405,8260,11678,295 "2009-01-26 00:00",36017,6517,0,293,1450,8260,11682,295 "2009-01-27 00:00",36042,6546,0,301,1511,8358,14080,295 "2009-01-28 00:00",36078,6601,1,301,1541,8444,14174,298 "2009-01-29 00:00",36135,6609,0,298,1754,8661,14236,298 "2009-01-30 00:00",9f84067,6614,0,300,1780,8692,14267,298 "2009-01-31 00:00",9f84067,6595,21,300,1778,8692,14267,298 "2009-02-01 00:00",48b6102,6595,21,300,1945,8859,14434,298 "2009-02-02 00:00",21f374f,6609,30,300,1944,8881,14593,299 "2009-02-03 00:00",21f374f,6609,30,300,1944,8881,14593,299 "2009-02-04 00:00",c3705e4,6609,30,300,1944,8881,14593,299 "2009-02-05 00:00",c108072,6629,0,301,1948,8878,14586,300 "2009-02-06 00:00",f990451,6629,0,301,1948,8878,14586,300 "2009-02-07 00:00",f990451,6629,0,301,1948,8878,14586,300 "2009-02-08 00:00",13f6779,6632,0,301,1982,8915,14586,301 "2009-02-09 00:00",1b85e1d,6635,0,301,1982,8918,14589,301 "2009-02-10 00:00",1b85e1d,6635,0,301,1982,8918,14589,301 "2009-02-11 00:00",e73c958,6635,0,301,1982,8918,14589,301 "2009-02-12 00:00",b2e7ac9,6766,0,299,1972,9037,14712,302 "2009-02-13 00:00",b2e7ac9,6766,0,299,1972,9037,14712,302 "2009-02-14 00:00",a0a3902,6812,0,298,1970,9080,14746,303 "2009-02-15 00:00",2f489f2,6812,0,298,1970,9080,14807,303 "2009-02-16 00:00",beac378,6805,15,298,1969,9087,14812,305 "2009-02-17 00:00",8695e4b,6823,0,298,1971,9092,14826,305 "2009-02-18 00:00",842ef38,6815,17,302,1981,9112,14836,306 "2009-02-19 00:00",444a4c8,6843,1,301,1985,9130,14861,306 "2009-02-20 00:00",5423d30,6952,0,303,1988,9243,15188,313 "2009-02-21 00:00",f23eda2,6951,15,307,1977,9250,15188,314 "2009-02-22 00:00",f23eda2,6955,15,307,1977,9254,15192,314 "2009-02-23 00:00",2a9382c,6970,0,307,1977,9254,15192,314 "2009-02-24 00:00",e074bf4,6999,0,308,1987,9294,15232,314 "2009-02-25 00:00",5944501,7007,0,310,1985,9302,15240,314 "2009-02-26 00:00",e6b7133,7041,0,309,1962,9312,15250,314 "2009-02-27 00:00",08b7890,7037,48,311,1947,9343,15261,315 "2009-02-28 00:00",c1f3976,7084,0,315,1944,9343,15261,315 "2009-03-01 00:00",af4b730,7084,0,315,1944,9343,15261,315 "2009-03-02 00:00",0d369db,7087,0,315,1944,9346,15268,315 "2009-03-03 00:00",4ec17da,7087,0,315,1944,9346,15268,315 "2009-03-04 00:00",55fb203,5648,0,284,1444,7376,15268,315 "2009-03-05 00:00",412cbe9,7121,0,314,1932,9367,15289,317 "2009-03-06 00:00",e47c348,7121,0,314,1932,9367,15289,317 "2009-03-07 00:00",f6cdf9b,7121,0,315,1932,9368,15290,317 "2009-03-08 00:00",ed4cd14,7122,2,318,1931,9373,15295,317 "2009-03-09 00:00",8bbc31c,7124,0,318,1931,9373,15295,317 "2009-03-10 00:00",95ce390,7015,140,321,1922,9398,15320,317 "2009-03-11 00:00",0c893bc,7148,0,319,1931,9398,15320,317 "2009-03-12 00:00",ea32839,7153,0,319,1926,9398,15320,317 "2009-03-13 00:00",087e299,7152,2,319,1935,9408,15330,317 "2009-03-14 00:00",41267fd,7166,0,319,1934,9419,15341,317 "2009-03-15 00:00",5b1ff9c,7174,0,315,1932,9421,15341,319 "2009-03-16 00:00",d2ad095,7174,0,316,1931,9421,15343,319 "2009-03-17 00:00",84920ea,7174,0,316,1934,9424,15346,319 "2009-03-18 00:00",521a5f1,7245,0,316,1919,9480,15356,321 "2009-03-19 00:00",f8b6aee,7255,0,318,1922,9495,15356,324 "2009-03-20 00:00",44e1496,7271,0,319,1926,9516,15382,325 "2009-03-21 00:00",627b6d6,7280,0,319,1942,9541,15407,325 "2009-03-22 00:00",de786f3,7280,0,319,1942,9541,15407,325 "2009-03-23 00:00",1c263b0,7308,1,324,1944,9577,15471,327 "2009-03-24 00:00",7487710,7322,1,324,1947,9594,15479,328 "2009-03-25 00:00",9a84c35,7367,0,324,1947,9638,15479,329 "2009-03-26 00:00",bb22e02,7424,0,325,1958,9707,15518,332 "2009-03-27 00:00",4929856,7795,0,326,2077,10198,15518,339 "2009-03-28 00:00",9fa0fca,7804,0,332,2062,10198,15518,339 "2009-03-29 00:00",7af829f,7804,0,332,2062,10198,15518,339 "2009-03-30 00:00",370dd76,8039,0,340,1819,10198,15518,339 "2009-03-31 00:00",c015556,8039,0,340,1819,10198,15518,339 "2009-04-01 00:00",78cb4c3,8049,0,342,1819,10210,15518,340 "2009-04-02 00:00",64e33af,8049,0,342,1819,10210,15518,340 "2009-04-03 00:00",913094f,8081,0,342,1816,10239,15534,344 "2009-04-04 00:00",68ea385,8406,0,342,1964,10712,15534,347 "2009-04-05 00:00",7dc65fd,8436,0,340,1960,10736,15579,349 "2009-04-06 00:00",078012a,8436,0,340,1960,10736,15579,349 "2009-04-07 00:00",8f4dc52,8436,0,340,1960,10736,15579,349 "2009-04-08 00:00",a2728b4,8444,0,342,1960,10746,15589,349 "2009-04-09 00:00",4ae560c,10224,0,343,2050,12617,15627,354 "2009-04-10 00:00",70fc009,10284,0,344,2052,12680,15633,356 "2009-04-11 00:00",79aba97,10300,0,346,2074,12720,15676,359 "2009-04-12 00:00",5b679a9,10298,5,346,2074,12723,15679,359 "2009-04-13 00:00",679e480,10298,5,346,2074,12723,15679,359 "2009-04-14 00:00",2c13d6c,10298,5,346,2074,12723,15679,359 "2009-04-15 00:00",d208e1c,10357,0,347,2148,12852,15801,362 "2009-04-16 00:00",a4535c1,10357,0,347,2148,12852,15801,362 "2009-04-17 00:00",a4535c1,10357,0,347,2148,12852,15801,362 "2009-04-18 00:00",f2c5829,10414,0,354,2153,12921,15860,371 "2009-04-19 00:00",d0310a3,10430,0,355,2151,12936,15866,372 "2009-04-20 00:00",0d55159,10381,0,360,2144,12885,15887,372 "2009-04-21 00:00",cea34fd,10389,0,359,2136,12884,15886,373 "2009-04-22 00:00",2665575,10467,0,358,2131,12956,15886,374 "2009-04-23 00:00",d79ccbe,10467,0,358,2133,12958,15888,374 "2009-04-24 00:00",9a53051,10907,0,353,2138,13398,16298,375 "2009-04-25 00:00",7bbc62a,10922,0,353,2136,13411,16311,376 "2009-04-26 00:00",705ecc2,10922,0,353,2136,13411,16311,376 "2009-04-27 00:00",c4f6763,10927,0,353,2137,13417,16317,376 "2009-04-28 00:00",467ade5,10931,0,363,2136,13430,16332,376 "2009-04-29 00:00",c76d8d0,10943,0,367,2146,13456,16343,377 "2009-04-30 00:00",96de998,10961,0,367,2145,13473,16364,378 "2009-05-01 00:00",b83a0b0,10958,0,367,2145,13470,16363,377 "2009-05-02 00:00",ec69e24,10991,0,364,2191,13546,16372,378 "2009-05-03 00:00",d4a0b3b,10984,7,364,2191,13546,16416,378 "2009-05-04 00:00",cddb162,10999,11,365,2190,13565,16487,379 "2009-05-05 00:00",4d7fe56,11011,0,364,2190,13565,16490,379 "2009-05-06 00:00",71c69d0,11013,0,364,2191,13568,16490,380 "2009-05-07 00:00",615936e,11022,0,365,2195,13582,16492,382 "2009-05-08 00:00",6db88b0,11032,0,365,2195,13592,16495,383 "2009-05-09 00:00",1f4ec5d,11028,66,360,2142,13596,16519,383 "2009-05-10 00:00",7d581a5,11085,1,362,2182,13630,16553,383 "2009-05-11 00:00",a27bbb6,11180,0,386,2213,13779,16562,387 "2009-05-12 00:00",feca3f2,11187,0,390,2213,13790,16573,387 "2009-05-13 00:00",3412a2f,11257,0,387,2182,13826,16581,388 "2009-05-14 00:00",8349d75,11258,1,387,2183,13829,16584,388 "2009-05-15 00:00",8ff0e0a,11291,0,390,2194,13875,16595,390 "2009-05-16 00:00",ec55f17,11288,8,389,2196,13881,16601,390 "2009-05-17 00:00",ec55f17,11288,8,389,2196,13881,16601,390 "2009-05-18 00:00",1639d85,11294,0,389,2199,13882,16603,390 "2009-05-19 00:00",9d2934e,11297,0,389,2199,13885,16603,391 "2009-05-20 00:00",595d364,11299,0,389,2199,13887,16623,391 "2009-05-21 00:00",f08f5ad,11342,0,390,2176,13908,16644,392 "2009-05-22 00:00",5eac9bd,11342,0,390,2176,13908,16644,392 "2009-05-23 00:00",23718a8,11342,0,390,2176,13908,16684,392 "2009-05-24 00:00",23718a8,11338,0,395,2175,13908,16684,392 "2009-05-25 00:00",23718a8,11337,0,395,2175,13907,16683,392 "2009-05-26 00:00",2376c44,11343,0,397,2178,13918,16685,394 "2009-05-27 00:00",6953001,11346,0,397,2178,13921,16685,395 "2009-05-28 00:00",b325177,11346,0,397,2178,13921,16685,395 "2009-05-29 00:00",6062528,11350,0,393,2178,13921,16685,395 "2009-05-30 00:00",764684b,11350,0,393,2178,13921,16685,395 "2009-05-31 00:00",764684b,11350,0,393,2178,13921,16685,395 "2009-06-01 00:00",0b9c9a3,11350,0,392,2180,13922,16686,395 "2009-06-02 00:00",d396ab4,11346,2,392,2182,13922,16686,395 "2009-06-03 00:00",c907d37,11348,2,392,2180,13922,16683,395 "2009-06-04 00:00",77db80c,11379,2,389,2190,13960,16683,399 "2009-06-05 00:00",10a9b23,11380,2,389,2190,13961,16684,399 "2009-06-06 00:00",fb2fd43,11391,2,389,2190,13972,16696,399 "2009-06-07 00:00",97f1415,11391,2,389,2190,13972,16696,399 "2009-06-08 00:00",5f70a68,11428,0,380,2165,13973,16697,399 "2009-06-09 00:00",063f3d5,11475,0,380,2165,14020,16744,400 "2009-06-10 00:00",86aeafb,11508,0,380,2168,14056,16838,401 "2009-06-11 00:00",86aeafb,11508,0,380,2168,14056,16838,401 "2009-06-12 00:00",a2b8ceb,11508,0,380,2168,14056,16841,401 "2009-06-13 00:00",4d21e2a,11514,0,380,2174,14068,16853,401 "2009-06-14 00:00",77f9d70,11535,0,382,2182,14099,16867,404 "2009-06-15 00:00",77f9d70,11535,0,382,2182,14099,16867,404 "2009-06-16 00:00",ba09b27,11535,0,382,2182,14099,16867,404 "2009-06-17 00:00",952fe6d,11536,0,381,2183,14100,16874,404 "2009-06-18 00:00",9dc941f,11536,0,381,2183,14100,16888,404 "2009-06-19 00:00",1b06df8,11536,0,381,2183,14100,16888,404 "2009-06-20 00:00",1b06df8,11488,48,381,2183,14100,16888,404 "2009-06-21 00:00",1b06df8,11488,48,381,2183,14100,16888,404 "2009-06-22 00:00",1b06df8,11532,4,381,2183,14100,16891,404 "2009-06-23 00:00",10f2235,11532,4,383,2184,14103,16894,404 "2009-06-24 00:00",0e0671a,11546,4,383,2184,14117,16908,405 "2009-06-25 00:00",0e0671a,11548,4,383,2183,14118,16909,405 "2009-06-26 00:00",6c43f93,11539,21,380,2218,14158,16921,406 "2009-06-27 00:00",6c43f93,11548,9,384,2218,14159,16925,406 "2009-06-28 00:00",6c43f93,11526,17,384,2221,14148,17010,406 "2009-06-29 00:00",6c43f93,11536,7,384,2221,14148,17010,406 "2009-06-30 00:00",1831bd1,11510,85,388,2223,14206,17026,409 "2009-07-01 00:00",5351a33,11592,52,384,2219,14245,17059,412 "2009-07-02 00:00",3d94ef4,11629,6,388,2226,14249,17063,412 "2009-07-03 00:00",f59630e,11546,90,387,2218,14241,17056,412 "2009-07-04 00:00",6a4d66a,11566,99,397,2216,14278,17067,412 "2009-07-05 00:00",6a4d66a,11577,85,400,2226,14288,17082,412 "2009-07-06 00:00",0e8a86a,11585,112,388,2175,14260,17136,411 "2009-07-07 00:00",99ad1eb,11497,125,403,2183,14208,17178,411 "2009-07-08 00:00",70bfd5c,11561,195,398,2195,14349,17197,412 "2009-07-09 00:00",70bfd5c,11577,195,403,2198,14373,17222,412 "2009-07-10 00:00",544038f,11748,0,410,2215,14373,17222,412 "2009-07-11 00:00",02d0ed2,11746,2,410,2215,14373,17224,412 "2009-07-12 00:00",02d0ed2,11750,2,415,2215,14382,17236,412 "2009-07-13 00:00",4024702,11796,0,420,2227,14443,17264,415 "2009-07-14 00:00",147b3d7,11784,0,426,2226,14436,17315,415 "2009-07-15 00:00",d8d0640,11787,3,430,2229,14447,17326,415 "2009-07-16 00:00",9a7a1dc,11792,2,430,2225,14449,17328,415 "2009-07-17 00:00",9a7a1dc,11802,2,441,2228,14473,17358,415 "2009-07-18 00:00",faf91f9,11813,3,442,2228,14486,17371,415 "2009-07-19 00:00",faf91f9,11815,1,442,2228,14486,17371,415 "2009-07-20 00:00",415514b,11835,1,461,2231,14528,17411,415 "2009-07-21 00:00",b756ac9,11854,0,473,2245,14572,17455,416 "2009-07-22 00:00",21066f1,11343,651,473,2101,14568,17453,416 "2009-07-23 00:00",6062092,11876,0,461,2238,14575,17460,416 "2009-07-24 00:00",fc60e1d,11913,0,462,2236,14611,17496,418 "2009-07-25 00:00",dd5767c,12006,0,537,2242,14785,17511,423 "2009-07-26 00:00",240b984,12027,0,543,2244,14814,17540,423 "2009-07-27 00:00",4c31fb7,12043,0,543,2244,14830,17556,423 "2009-07-28 00:00",ea667e8,12033,14,540,2248,14835,17556,423 "2009-07-29 00:00",6999e58,12048,8,541,2253,14850,17571,423 "2009-07-30 00:00",13ba2f3,12114,8,502,2210,14834,17583,423 "2009-07-31 00:00",a53a1cd,12124,8,511,2210,14853,17602,424 "2009-08-01 00:00",e02bc06,12124,8,512,2214,14858,17609,424 "2009-08-02 00:00",e02bc06,12126,13,512,2214,14865,17616,424 "2009-08-03 00:00",91408af,12179,8,520,2226,14933,17588,426 "2009-08-04 00:00",18598de,12179,8,520,2226,14933,17588,426 "2009-08-05 00:00",24b26a0,12185,8,524,2227,14944,17599,426 "2009-08-06 00:00",a948cae,12189,8,528,2227,14952,17607,426 "2009-08-07 00:00",4665d75,12156,65,528,2206,14955,17610,426 "2009-08-08 00:00",7717c4a,12193,16,531,2221,14961,17622,426 "2009-08-09 00:00",5667dca,12247,0,529,2286,15062,17595,429 "2009-08-10 00:00",39cc848,12303,0,530,2286,15119,17611,430 "2009-08-11 00:00",11a2934,12301,0,533,2259,15093,17625,429 "2009-08-12 00:00",a5dfe96,12303,0,535,2260,15098,17636,428 "2009-08-13 00:00",69eee0d,12308,0,538,2263,15109,17647,428 "2009-08-14 00:00",0d4fe08,12294,0,525,2268,15087,17619,428 "2009-08-15 00:00",637d803,12298,21,522,2262,15103,17632,429 "2009-08-16 00:00",ada2b41,12326,0,526,2267,15119,17650,429 "2009-08-17 00:00",5637208,12326,0,526,2267,15119,17665,429 "2009-08-18 00:00",55c5fa1,12339,1,524,2265,15129,17675,430 "2009-08-19 00:00",b9c79c2,12339,0,523,2267,15129,17675,430 "2009-08-20 00:00",fd8fc8a,12371,0,516,2263,15150,17682,431 "2009-08-21 00:00",ae56d02,12376,0,516,2263,15155,18193,431 "2009-08-22 00:00",0a5b07e,12397,0,514,2263,15174,18204,433 "2009-08-23 00:00",e83932a,12397,0,514,2263,15174,18204,433 "2009-08-24 00:00",c4c67da,12399,0,514,2266,15179,18209,433 "2009-08-25 00:00",9d9d416,12401,0,514,2264,15179,18209,433 "2009-08-26 00:00",bd51ce2,12402,0,513,2267,15182,18212,433 "2009-08-27 00:00",ec2f831,12402,0,513,2267,15182,18212,433 "2009-08-28 00:00",f351f60,12391,0,517,2274,15182,18212,433 "2009-08-29 00:00",7666e92,12393,0,516,2273,15182,18241,433 "2009-08-30 00:00",7666e92,12465,0,520,2274,15259,18289,433 "2009-08-31 00:00",8772e90,12478,0,517,2274,15269,18299,433 "2009-09-01 00:00",9bcba63,12550,0,520,2381,15451,18481,435 "2009-09-02 00:00",ba10463,13245,0,521,2414,16180,19210,435 "2009-09-03 00:00",c9a9300,13257,0,521,2414,16192,19222,435 "2009-09-04 00:00",b51d94c,13402,0,521,2446,16369,19399,435 "2009-09-05 00:00",2276af9,13401,2,521,2445,16369,19399,435 "2009-09-06 00:00",6e2104a,13404,0,518,2447,16369,19403,435 "2009-09-07 00:00",205733f,14255,0,518,2783,17556,20590,435 "2009-09-08 00:00",01ae3fa,14273,0,518,2783,17574,20599,436 "2009-09-09 00:00",62879bb,14268,0,521,2785,17574,20599,436 "2009-09-10 00:00",5960161,14272,0,521,2785,17578,20603,436 "2009-09-11 00:00",d0355a5,14267,5,521,2785,17578,20603,436 "2009-09-12 00:00",3b63817,14835,0,521,2832,18188,21213,436 "2009-09-13 00:00",0f1edeb,15494,0,521,2657,18672,21697,436 "2009-09-14 00:00",0f1edeb,15500,0,523,2659,18682,21679,436 "2009-09-15 00:00",a9ff309,15500,0,523,2659,18682,21679,436 "2009-09-16 00:00",9a61441,15497,0,518,2651,18666,21671,436 "2009-09-17 00:00",ea6448f,15497,0,518,2651,18666,21671,436 "2009-09-18 00:00",a969c9e,15498,0,520,2651,18669,21674,436 "2009-09-19 00:00",4b141a8,15498,0,520,2651,18669,21674,436 "2009-09-20 00:00",2c40a5b,15498,0,521,2651,18670,21695,436 "2009-09-21 00:00",2c40a5b,15498,0,521,2651,18670,21695,436 "2009-09-22 00:00",5d3d3a3,15498,0,521,2651,18670,21695,436 "2009-09-23 00:00",0220cc2,15506,0,521,2658,18685,21710,436 "2009-09-24 00:00",e9a7966,15506,0,521,2658,18685,21710,436 "2009-09-25 00:00",729722a,15515,0,521,2651,18687,21712,436 "2009-09-26 00:00",729722a,15515,0,521,2651,18687,21712,436 "2009-09-27 00:00",834929c,15518,0,525,2651,18694,21719,436 "2009-09-28 00:00",0331d60,15513,0,520,2648,18681,21729,436 "2009-09-29 00:00",0331d60,15512,0,520,2650,18682,21730,436 "2009-09-30 00:00",2d34081,12778,98,520,2134,15404,18458,436 "2009-10-01 00:00",ffe6481,15956,0,520,2650,19126,22180,436 "2009-10-02 00:00",f52e459,15966,0,515,2660,19141,22195,436 "2009-10-03 00:00",e976f23,27697,0,515,6847,35059,38113,449 "2009-10-04 00:00",e976f23,26949,1,515,6847,34309,37363,449 "2009-10-05 00:00",1ca164a,27717,2,514,6838,35071,38088,449 "2009-10-06 00:00",d91717d,27720,0,517,6839,35076,38093,449 "2009-10-07 00:00",8d63378,27718,2,517,6839,35076,38093,449 "2009-10-08 00:00",30e2cfd,27719,0,515,6841,35075,38092,449 "2009-10-09 00:00",daf221d,27719,0,515,6841,35075,38092,449 "2009-10-10 00:00",1b83557,27754,0,521,6846,35121,38138,450 "2009-10-11 00:00",7ec926f,27776,0,518,6847,35141,38158,450 "2009-10-12 00:00",d749d9b,27835,0,521,6868,35224,38211,452 "2009-10-13 00:00",d749d9b,27836,0,521,6867,35224,38211,452 "2009-10-14 00:00",54cfe42,27840,0,520,6874,35234,38221,452 "2009-10-15 00:00",3eceb87,27842,0,521,6876,35239,38226,452 "2009-10-16 00:00",d5a2ee9,27804,0,521,6876,35201,38188,452 "2009-10-17 00:00",d5a2ee9,27804,0,521,6876,35201,38188,452 "2009-10-18 00:00",dc9e98e,0,27804,521,6876,35201,38188,452 "2009-10-19 00:00",827734a,27879,0,523,6902,35304,38291,452 "2009-10-20 00:00",9d76f3b,32365,83,523,2333,35304,38291,452 "2009-10-21 00:00",db1e525,32568,104,485,2140,35297,38284,453 "2009-10-22 00:00",0e662a7,32614,83,491,2151,35339,38326,453 "2009-10-23 00:00",49e62fa,32616,83,493,2156,35348,38335,454 "2009-10-24 00:00",501b4fb,32618,83,493,2157,35351,38335,454 "2009-10-25 00:00",501b4fb,32621,83,494,2160,35358,38342,454 "2009-10-26 00:00",6817b90,32621,83,494,2164,35362,38337,454 "2009-10-26 00:00",571425b,0,32621,494,2164,35362,38337,454 "2009-10-28 00:00",e8cac16,32714,7,496,2188,35405,38373,454 "2009-10-29 00:00",8cf27e5,32721,7,500,2192,35420,38388,454 "2009-10-30 00:00",4320479,31697,17,499,2187,34175,37143,454 "2009-10-31 00:00",d154eb9,32729,7,499,2187,35422,38390,454 "2009-11-01 00:00",d154eb9,32701,37,499,2187,35424,38392,454 "2009-11-02 00:00",33111d4,32609,120,498,2161,35388,38356,452 "2009-11-03 00:00",74f561e,32609,117,498,2164,35388,38356,452 "2009-11-04 00:00",16eab0f,32613,117,498,2164,35392,38360,452 "2009-11-05 00:00",5e05b88,32685,7,516,2196,35404,38372,451 "2009-11-06 00:00",5e05b88,32685,7,516,2196,35404,38372,451 "2009-11-07 00:00",fe6dd27,32688,7,513,2196,35404,38372,451 "2009-11-08 00:00",37d480a,32677,13,512,2196,35398,38374,451 "2009-11-09 00:00",929998c,32696,5,514,2196,35411,38379,451 "2009-11-10 00:00",929998c,32696,15,516,2196,35423,38389,451 "2009-11-11 00:00",f16c9e2,32705,6,516,2196,35423,38389,451 "2009-11-12 00:00",f87efac,31444,11,525,2197,33683,36618,453 "2009-11-13 00:00",d04cce9,32734,8,525,2198,35465,38400,453 "2009-11-14 00:00",d04cce9,32737,8,532,2201,35478,38378,453 "2009-11-15 00:00",7347ec0,32738,8,532,2201,35479,38379,453 "2009-11-16 00:00",7347ec0,32737,10,534,2204,35485,38380,453 "2009-11-17 00:00",d3a573b,32742,6,534,2206,35407,38302,453 "2009-11-18 00:00",68d5c37,32742,6,534,2206,35407,38302,453 "2009-11-19 00:00",c00de9d,32753,5,537,2209,35423,38318,453 "2009-11-20 00:00",f5065b6,32723,16,534,2194,35467,38367,453 "2009-11-21 00:00",6bf0179,32769,16,538,2214,35537,38538,453 "2009-11-22 00:00",6bf0179,32769,16,538,2214,35537,38538,453 "2009-11-23 00:00",6bf0179,32759,16,540,2222,35537,38538,453 "2009-11-24 00:00",0a61bee,32794,8,542,2222,35563,38564,453 "2009-11-25 00:00",0a61bee,32771,31,542,2222,35563,38564,453 "2009-11-26 00:00",f151334,32540,134,531,2184,35262,38263,453 "2009-11-27 00:00",f151334,32540,134,531,2185,35263,38264,453 "2009-11-28 00:00",2b93c78,32557,134,537,2185,35286,38287,453 "2009-11-29 00:00",7ce13d8,32538,0,528,2216,35295,38296,453 "2009-11-30 00:00",7ce13d8,32536,0,528,2218,35295,38296,453 "2009-12-01 00:00",ef9c024,32536,0,528,2218,35295,38296,453 "2009-12-02 00:00",ef9c024,32536,0,528,2218,35295,38296,453 "2009-12-03 00:00",7914ca3,32536,0,528,2218,35295,38296,453 "2009-12-04 00:00",7ef3861,32509,0,528,2218,35298,38299,453 "2009-12-05 00:00",7ef3861,32539,0,527,2218,35298,38299,453 "2009-12-06 00:00",7ef3861,32539,0,527,2218,35298,38299,453 "2009-12-07 00:00",7ef3861,32406,0,527,2208,35160,38161,453 "2009-12-08 00:00",7ef3861,32270,0,545,2009,35166,38167,453 "2009-12-09 00:00",7ef3861,32259,0,546,2021,35171,38172,453 "2009-12-10 00:00",7ef3861,32259,0,546,2021,35171,38172,453 "2009-12-11 00:00",7ef3861,32258,0,546,2021,35171,38172,453 "2009-12-12 00:00",7ef3861,32255,0,545,2025,35172,38173,453 "2009-12-13 00:00",7ef3861,32255,0,543,2027,35172,38173,453 "2009-12-14 00:00",7ef3861,32255,0,543,2027,35172,38173,453 "2009-12-15 00:00",7ef3861,32225,0,543,2027,35172,38173,453 "2009-12-16 00:00",55f51dc,32255,0,543,2027,35172,38173,453 "2009-12-17 00:00",2198ecc,32192,0,543,2021,34311,37376,449 "2009-12-18 00:00",7f1c3fe,32084,0,541,2009,34237,37313,448 "2009-12-19 00:00",7f1c3fe,32080,0,541,2006,34237,37313,448 "2009-12-20 00:00",8dc1895,32080,0,541,2006,34237,37313,448 "2009-12-21 00:00",8dc1895,32080,0,541,2006,34237,37313,448 "2009-12-22 00:00",8dc1895,32080,0,541,2006,34237,37313,448 "2009-12-23 00:00",8dc1895,32080,0,541,2006,34237,37313,448 "2009-12-24 00:00",8dc1895,32080,0,541,2006,34237,37313,448 "2009-12-25 00:00",8dc1895,32080,0,541,2006,34237,37313,448 "2009-12-26 00:00",8dc1895,32080,0,541,2006,34237,37313,448 "2009-12-27 00:00",8dc1895,32075,0,541,2002,34245,37321,448 "2009-12-28 00:00",77bf8cf,32075,0,541,2002,34245,37321,448 "2009-12-29 00:00",77bf8cf,32045,0,545,2004,34221,37297,448 "2009-12-30 00:00",db84bc0,32045,0,548,2004,34224,37300,448 "2009-12-31 00:00",db84bc0,32045,0,548,2004,34224,37300,448 "2010-01-01 00:00",db84bc0,32041,0,547,2005,34224,37300,448 "2010-01-02 00:00",db84bc0,32041,0,547,2005,34224,37300,448 "2010-01-03 00:00",db84bc0,32041,0,547,2005,34224,37300,448 "2010-01-04 00:00",db84bc0,32041,0,547,2005,34224,37300,448 "2010-01-05 00:00",3867ffd,32038,0,546,2001,34216,37292,448 "2010-01-06 00:00",3867ffd,32038,0,546,2001,34216,37292,448 "2010-01-07 00:00",3867ffd,32038,0,546,2001,34216,37292,448 "2010-01-08 00:00",3867ffd,32038,0,546,2001,34216,37292,448 "2010-01-09 00:00",3867ffd,32012,0,545,1984,34172,37248,448 "2010-01-10 00:00",3867ffd,32012,0,545,1984,34172,37248,448 "2010-01-11 00:00",3867ffd,32007,0,544,1990,34172,37248,448 "2010-01-12 00:00",3867ffd,32007,0,544,1997,34176,37252,448 "2010-01-13 00:00",3867ffd,32007,0,544,1997,34176,37252,448 "2010-01-14 00:00",3867ffd,32007,0,544,1997,34176,37252,448 "2010-01-15 00:00",3867ffd,32007,0,544,1997,34176,37252,448 "2010-01-16 00:00",3867ffd,31958,0,544,1999,34179,37255,447 "2010-01-17 00:00",3867ffd,31958,0,544,1999,34179,37255,447 "2010-01-18 00:00",726b83a,31958,0,544,1999,34179,37255,447 "2010-01-19 00:00",726b83a,31958,0,544,1999,34179,37255,447 "2010-01-20 00:00",726b83a,31957,0,545,1999,34179,37268,447 "2010-01-21 00:00",1d49284,31957,0,545,1999,34179,37268,447 "2010-01-22 00:00",1d49284,31957,0,545,1999,34179,37268,447 "2010-01-24 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-01-25 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-01-26 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-01-27 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-01-28 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-01-29 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-01-30 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-01-31 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-02-01 00:00",a609d77,32731,0,542,2216,35489,38554,449 "2010-02-02 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-03 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-04 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-05 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-06 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-07 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-08 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-09 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-10 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-11 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-12 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-13 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-14 00:00",30e0ed3,32731,0,542,2216,35489,38554,449 "2010-02-15 00:00",70667a0,4051,0,58,336,4445,16418,139 "2010-02-16 00:00",65e2d3d,4085,0,58,336,4479,16428,140 "2010-02-17 00:00",6c478f2,4816,1,129,279,5225,16525,172 "2010-02-18 00:00",b4824f3,24167,0,131,301,24599,35727,194 "2010-02-19 00:00",8fdc942,24221,0,131,301,24653,35730,195 "2010-02-20 00:00",71d8848,24223,0,129,301,24653,35730,195 "2010-02-21 00:00",e904536,23424,20,122,296,23862,34939,195 "2010-02-22 00:00",14f803a,23424,20,122,296,23862,34872,195 "2010-02-23 00:00",d6129bc,24265,0,130,317,24712,35680,197 "2010-02-24 00:00",4f74e3b,24309,0,128,319,24756,35677,200 "2010-02-25 00:00",88f57f6,24339,0,128,331,24798,35695,204 "2010-02-26 00:00",403afe0,24575,1,139,426,25141,35754,215 "2010-02-27 00:00",c83cf2a,24645,0,139,422,25206,35748,216 "2010-02-28 00:00",8ffb7ea,24884,2,151,469,25506,35854,225 "2010-03-01 00:00",588a345,23508,0,162,500,24072,34217,231 "2010-03-02 00:00",5e5969d,25342,0,181,522,26045,35961,240 "2010-03-03 00:00",efb2ccd,25346,0,183,522,26051,35967,240 "2010-03-04 00:00",cee8058,25346,2,181,522,26051,35973,240 "2010-03-05 00:00",2d9808d,25354,1,182,522,26059,35975,241 "2010-03-06 00:00",974d9a8,25404,0,187,532,26091,35978,243 "2010-03-07 00:00",54be6dd,25678,1,201,526,26406,36153,256 "2010-03-08 00:00",f56934d,26687,0,262,789,27738,37279,272 "2010-03-09 00:00",0162536,26860,0,264,814,27938,37320,279 "2010-03-10 00:00",88032ee,27015,0,271,946,28232,37601,287 "2010-03-11 00:00",e634b58,27019,0,271,944,28234,37603,287 "2010-03-12 00:00",3f6af6a,27155,0,286,986,28427,37730,293 "2010-03-13 00:00",41506d4,27256,0,301,1036,28593,37739,302 "2010-03-14 00:00",fefb298,27412,0,308,1076,28796,37867,310 "2010-03-15 00:00",c29d389,27562,0,319,1190,29071,37963,318 "2010-03-16 00:00",f676705,25945,1,316,1197,27404,36272,322 "2010-03-17 00:00",e3937f7,27628,0,319,1205,29152,38020,322 "2010-03-18 00:00",2abcdcd,27764,1,340,1190,29295,38109,332 "2010-03-19 00:00",1e9aa08,27767,0,334,1170,29271,38079,333 "2010-03-20 00:00",a6e9e13,28068,0,356,1174,29598,38075,336 "2010-03-21 00:00",6be8f8c,28312,1,368,1200,29881,38165,338 "2010-03-22 00:00",265726d,28428,2,369,1214,30013,38190,343 "2010-03-23 00:00",eae8b29,28474,2,374,1250,30100,38271,348 "2010-03-24 00:00",d0bf6e3,28549,2,375,1218,30144,38280,354 "2010-03-25 00:00",626ee20,28553,0,375,1218,30146,38286,354 "2010-03-26 00:00",b2f995a,28730,0,415,1304,30449,38287,359 "2010-03-27 00:00",cddc8a7,28730,0,415,1298,30443,38281,359 "2010-03-28 00:00",cddc8a7,28730,0,415,1298,30443,38281,359 "2010-03-29 00:00",534afd8,28765,0,429,1309,30503,38307,361 "2010-03-30 00:00",534afd8,28765,0,429,1309,30503,38307,361 "2010-03-31 00:00",8ba6030,28799,1,430,1362,30592,38396,362 "2010-04-01 00:00",7d00af1,28872,1,438,1401,30712,38488,366 "2010-04-02 00:00",63ff066,28928,1,435,1378,30742,38494,369 "2010-04-03 00:00",e50ff8c,30369,1,435,1454,32259,38496,378 "2010-04-04 00:00",32fda13,30443,1,426,1458,32328,38513,380 "2010-04-05 00:00",4d1b1c7,30515,2,448,1491,32456,38537,385 "2010-04-06 00:00",3b1d348,30548,10,445,1493,32496,38577,386 "2010-04-07 00:00",8c434e8,30552,2,451,1493,32416,38486,387 "2010-04-08 00:00",8c434e8,30564,2,451,1493,32510,38580,387 "2010-04-09 00:00",8681735,30571,2,451,1489,32513,38582,388 "2010-04-10 00:00",43f8659,30570,2,452,1489,32513,38582,388 "2010-04-11 00:00",9406f55,30446,145,446,1441,32422,38491,388 "2010-04-12 00:00",8b256a9,30568,2,452,1491,32431,38500,388 "2010-04-13 00:00",cb45216,30609,2,453,1498,32562,38595,390 "2010-04-14 00:00",fb38dbf,30604,2,453,1503,32562,38595,390 "2010-04-15 00:00",2ec0e4e,30626,2,454,1509,32591,38595,391 "2010-04-16 00:00",78faa0c,30634,2,448,1507,32591,38595,391 "2010-04-17 00:00",78faa0c,30641,2,450,1507,32600,38604,391 "2010-04-18 00:00",78faa0c,30643,2,450,1507,32602,38606,391 "2010-04-19 00:00",842d2b0,30701,4,450,1507,32662,38666,392 "2010-04-20 00:00",b05155e,30751,2,457,1505,32715,38688,392 "2010-04-21 00:00",483a9da,30785,0,449,1522,32674,38627,397 "2010-04-22 00:00",98f05df,30887,0,450,1523,32774,38645,402 "2010-04-23 00:00",6783b52,31502,64,453,1634,33653,38728,410 "2010-04-24 00:00",de2ad34,31558,0,465,1632,33655,38731,410 "2010-04-26 00:00",f6ec0aa,31686,0,468,1650,33804,38790,417 "2010-04-27 00:00",1cdbc19,31695,19,473,1653,33840,38804,419 "2010-04-28 00:00",6a502fc,31707,1,479,1646,33833,38798,419 "2010-04-29 00:00",fe59fa8,31740,0,480,1633,33853,38818,419 "2010-04-30 00:00",f31d524,31142,724,464,1533,33863,38828,419 "2010-05-01 00:00",376196d,31178,724,455,1577,33934,38890,420 "2010-05-02 00:00",8abe0a6,31807,1,468,1694,33970,38898,421 "2010-05-03 00:00",b440a11,31789,47,470,1685,33991,38898,423 "2010-05-04 00:00",124895a,31846,0,473,1684,34003,38908,424 "2010-05-05 00:00",60c23d9,31846,0,473,1684,34003,38908,424 "2010-05-06 00:00",badc61d,30996,67,471,1685,33219,38094,426 "2010-05-07 00:00",ab23221,31873,11,474,1695,34039,38904,427 "2010-05-08 00:00",9427875,31864,10,475,1698,34041,38896,428 "2010-05-09 00:00",27e05a8,31966,24,475,1710,34170,39002,432 "2010-05-10 00:00",3d3893a,32005,0,532,1660,34197,39026,432 "2010-05-11 00:00",ed24098,32005,0,532,1660,34197,39026,433 "2010-05-12 00:00",ed24098,32015,0,532,1663,34210,39039,433 "2010-05-13 00:00",ed24098,32015,0,532,1663,34210,39039,433 "2010-05-14 00:00",da421b4,30785,0,532,1663,32963,37792,433 "2010-05-15 00:00",82f7ef3,32129,0,527,1652,34308,39137,433 "2010-05-16 00:00",92508d6,32144,0,529,1648,34321,39142,434 "2010-05-17 00:00",87e0e1b,32144,0,529,1648,34321,39142,434 "2010-05-18 00:00",2d0fc2b,32187,0,527,1666,34380,39183,437 "2010-05-19 00:00",5ec28d3,32257,0,527,1684,34461,39252,446 "2010-05-20 00:00",8292d45,32346,1,530,1682,34559,39356,448 "2010-05-21 00:00",e6863e4,32347,0,530,1682,34559,39356,448 "2010-05-22 00:00",9a15b82,32422,0,530,1684,34636,39433,451 "2010-05-23 00:00",eb84e91,32474,2,531,1689,34680,39434,457 "2010-05-24 00:00",10a3218,32517,0,531,1648,34696,39450,457 "2010-05-25 00:00",52a1375,32492,4,530,1646,34672,39455,456 "2010-05-26 00:00",475d1c7,32519,2,537,1628,34618,39395,460 "2010-05-27 00:00",e40ee42,32555,8,537,1647,34747,39520,460 "2010-05-28 00:00",ac1571f,32574,8,537,1646,34765,39538,460 "2010-05-29 00:00",9581e6a,32632,552,539,1641,35351,39542,471 "2010-05-30 00:00",dd0e5dd,32920,0,605,1857,35382,39573,471 "2010-05-31 00:00",4f9ca44,32962,1,608,1880,35451,39661,473 "2010-06-01 00:00",18d9960,33046,0,609,1871,35526,39736,473 "2010-06-02 00:00",18d9960,33063,0,609,1872,35544,39754,473 "2010-06-03 00:00",18d9960,0,33063,609,1872,35544,39754,473 "2010-06-04 00:00",e92a5f4,33172,0,607,1884,35663,39822,474 "2010-06-05 00:00",7c83e65,33223,2,607,1889,35721,39886,474 "2010-06-06 00:00",c0efe09,33258,4,606,1892,35760,39898,476 "2010-06-07 00:00",a1193fe,33296,0,609,1896,35801,39929,478 "2010-06-08 00:00",34c1ba4,33358,0,609,1890,35857,39985,479 "2010-06-09 00:00",9f05efa,33360,0,609,1890,35859,39987,479 "2010-06-10 00:00",16d9cb0,33360,0,609,1890,35859,39987,479 "2010-06-11 00:00",d59da85,33384,1,611,1890,35886,40009,481 "2010-06-12 00:00",52873b9,33323,1,611,1890,35825,39948,480 "2010-06-13 00:00",ecacff9,33361,1,614,1880,35856,39979,480 "2010-06-14 00:00",ca5bfc1,29096,3284,379,1209,32548,36671,480 "2010-06-15 00:00",11f835f,32370,641,562,1709,35017,39140,480 "2010-06-16 00:00",b6cc36c,32838,272,568,1772,35416,39649,473 "2010-06-17 00:00",fdb5ca4,33280,37,608,1935,35853,39887,489 "2010-06-18 00:00",3da39cf,33443,4,592,1916,35955,39960,490 "2010-06-19 00:00",683a745,33461,30,595,1906,35992,39969,492 "2010-06-20 00:00",b98d7fa,33534,55,594,1945,36128,40037,496 "2010-06-21 00:00",1277e18,33592,0,598,1951,36141,40050,496 "2010-06-22 00:00",7b089e5,33605,0,596,1937,36138,40047,496 "2010-06-23 00:00",11cbd4f,33610,0,597,1940,36147,40056,496 "2010-06-24 00:00",11cbd4f,33572,2,597,1916,36023,39932,495 "2010-06-25 00:00",f34e780,33587,0,600,1943,36130,40039,495 "2010-06-26 00:00",6769e19,33594,0,599,1938,36131,40040,496 "2010-06-27 00:00",2334011,33656,2,586,1921,36165,40074,496 "2010-06-28 00:00",05684c0,33663,0,584,1918,36165,40074,496 "2010-06-29 00:00",871e2fb,33718,4,569,1924,36215,40091,497 "2010-06-30 00:00",aa015ad,33735,1,569,1937,36238,40102,500 "2010-07-01 00:00",3d2cb82,33744,1,568,1937,36250,40114,500 "2010-07-02 00:00",fcf394a,33678,22,568,1932,36193,40057,501 "2010-07-03 00:00",0ad106c,33505,177,558,1915,36155,40021,501 "2010-07-04 00:00",77ca4f5,33767,55,568,1937,36327,40182,504 "2010-07-05 00:00",ef66ac3,33832,3,565,1940,36340,40195,505 "2010-07-06 00:00",55acd1d,33927,19,558,1907,36411,40197,507 "2010-07-07 00:00",f8dde0a,33926,2,568,1905,36383,40171,507 "2010-07-08 00:00",894e793,33910,0,568,1905,36383,40163,507 "2010-07-09 00:00",1086ff8,34010,12,573,1940,36534,40163,513 "2010-07-10 00:00",7579f7a,34118,3,580,1883,36584,40171,515 "2010-07-11 00:00",7579f7a,34085,3,578,1881,36543,40130,515 "2010-07-12 00:00",bb6df24,34111,26,579,1879,36544,40131,515 "2010-07-13 00:00",ae4538a,34143,29,581,1885,36591,40178,515 "2010-07-14 00:00",c8b6cf4,34157,16,596,1876,36598,40183,516 "2010-07-15 00:00",d51e99a,23534,5,600,1876,26015,20985,515 "2010-07-16 00:00",c513fbd,23507,13,600,1875,25995,20955,516 "2010-07-17 00:00",dd8d5d7,23527,5,596,1875,26003,20963,516 "2010-07-18 00:00",cd64dd0,23415,83,583,1868,25835,20749,518 rakudo-2015.11/docs/val.pod6000644 000765 000024 00000011675 12600026162 017432 0ustar00williamcoledastaff000000 000000 =begin pod This document is meant to describe in some detail what's going on in C (found in C), since it's quite a big function. It contains a bunch of inner subs to make the process as sane as possible without resorting to a grammar. The phrase "or fails" in statements on return values means it returns a C, something that always presents itself as undefined. The C<$*LAST_CHANCE> dynamic (defined within C) is used to mark a given candidate as the last possible one, even if it isn't the last in the list (see below on C and C). The top-level (first) call to C will set C<$really-no-doubt> to C<$*LAST_CHANCE> as part of the error reporting process. =head2 C The C class is just a hack, because using Cs in a similar way will cause Perl 6 to hang and likely eat all your memory (including on compiling C, the next step after C). Its only similarity to a C is that it always comes out as undefined (so it can be used with C/C/C). Aside from that it's meant to collect the error information as the literal is processed, turning into a C at the end. =head2 C =item C --- Checks for a negative sign at the start of the string =item2 Returns C<1> or C<0>, to match the flag for C =item C --- Checks if the start of string is a C<+> or C<-> =item2 Returns C<1> or C<0>, to match C (though these particular return values aren't otherwise important) =item C --- Check for oh radix prefix (0x, 0d, 0b, 0o) =item2 Returns new radix or fails =item C --- Runs through a sequence of subs in trying to find a literal, or part of one. =item2 Adverb C<:toplevel> sets C<$really-no-doubt> to C<$*LAST_CHANCE> (meant to let the top-level call to C add a measure of doubt to the given error message) =item2 Returns a literal or fails (with the last candidate's C) =item2 In regex terms, similar to C<||> =item C --- Sets C<$*LAST_CHANCE>, thereby telling C that the sub which called this has to be the one that matches the literal. In other words, it's called by a candidate when it knows that the literal "has to be this" candidate. =item2 Returns nothing useful. =item2 In regex terms, similar to C<::> =head2 C =item Bare integer --- C --- C<42>, C<-12>, C<0xF>, etc. =item2 Options: =item3 C<:e> --- used when calling from C =item3 C<:nosign> --- used when calling from C =item2 Requires: =item3 C (unless C<:nosign>) =item3 C (unless C<:e>) =item2 Returns C or fails =item Radix point rational --- C --- C<3.2>, C<-5.4> =item2 Options: =item3 C<:adverb> --- used when calling from C, allows oh radices =item3 C<:nosign> --- passed through for C, and used in here =item2 Requires: =item3 C (for before point portion) =item3 C (unless C<:nosign>) =item3 C (only if C<:adverb>) =item2 Returns C or fails =item Scientific C --- C --- C<1e5>, C<-3.5e-2> =item2 Requires: =item3 C (coefficient) =item3 C (exponent, base of 10 implied) =item2 Returns C or fails =item Adverbial number --- C --- C«:16», C«:11<0o7.7*8**2>», etc. =item2 Options: =item3 C<:nofrac> --- used when calling from C =item3 C<:nosign> --- controls whether a sign can be in front of the adverb =item2 Requires: =item3 C (for radix specifier, integer coeff) =item3 C (non-int coefficient) =item3 C (optional base in :#<> form) =item3 C (optional base in :#<> form) =item3 C (optional exp in :#<> form) =item3 C (optional exp in :#<> form) =item2 Returns: =item3 C if optional base and exponent; =item3 C without base and exponent, non-integral number; =item3 C without base and exponent, integral number; =item3 or fails =item Fractional rational --- C --- C«1/2», C«-3/:16», etc =item2 Requires: =item3 C (for :#<> form numerator) =item3 C (for bare integers in numerator) =item3 C (for :#<> form denominator) =item3 C (for bare integers in numerator) =item2 Returns C or fails =item Complex number --- C --- C<1+2i>, C<-3.5+-1i>, etc =item2 Requires: =item3 C =item3 C =item3 C =item3 C =item2 Returns C or fails =end podrakudo-2015.11/dynext/IGNORE000644 000765 000024 00000000045 12573545401 017347 0ustar00williamcoledastaff000000 000000 This space intentionally left blank. rakudo-2015.11/gen/jvm/.gitignore000644 000765 000024 00000000002 12573545401 020454 0ustar00williamcoledastaff000000 000000 * rakudo-2015.11/gen/moar/.gitignore000644 000765 000024 00000000002 12600026600 020600 0ustar00williamcoledastaff000000 000000 * rakudo-2015.11/lib/NativeCall.pm000644 000765 000024 00000032413 12623467502 020261 0ustar00williamcoledastaff000000 000000 use nqp; module NativeCall { use NativeCall::Types; use NativeCall::Compiler::GNU; use NativeCall::Compiler::MSVC; my constant long is export(:types, :DEFAULT) = NativeCall::Types::long; my constant longlong is export(:types, :DEFAULT) = NativeCall::Types::longlong; my constant ulong is export(:types, :DEFAULT) = NativeCall::Types::ulong; my constant ulonglong is export(:types, :DEFAULT) = NativeCall::Types::ulonglong; my constant void is export(:types, :DEFAULT) = NativeCall::Types::void; my constant CArray is export(:types, :DEFAULT) = NativeCall::Types::CArray; my constant Pointer is export(:types, :DEFAULT) = NativeCall::Types::Pointer; my constant OpaquePointer is export(:types, :DEFAULT) = NativeCall::Types::Pointer; # Throwaway type just to get us some way to get at the NativeCall # representation. my class native_callsite is repr('NativeCall') { } # Maps a chosen string encoding to a type recognized by the native call engine. sub string_encoding_to_nci_type($enc) { given $enc { when 'utf8' { 'utf8str' } when 'utf16' { 'utf16str' } when 'ascii' { 'asciistr' } default { die "Unknown string encoding for native call: $enc"; } } } # Builds a hash of type information for the specified parameter. sub param_hash_for(Parameter $p, :$with-typeobj) { my Mu $result := nqp::hash(); my $type := $p.type(); nqp::bindkey($result, 'typeobj', nqp::decont($type)) if $with-typeobj; nqp::bindkey($result, 'rw', nqp::unbox_i(1)) if $p.rw; if $type ~~ Str { my $enc := $p.?native_call_encoded() || 'utf8'; nqp::bindkey($result, 'type', nqp::unbox_s(string_encoding_to_nci_type($enc))); nqp::bindkey($result, 'free_str', nqp::unbox_i(1)); } elsif $type ~~ Callable { nqp::bindkey($result, 'type', nqp::unbox_s(type_code_for($p.type))); my $info := param_list_for($p.sub_signature, :with-typeobj); nqp::unshift($info, return_hash_for($p.sub_signature, :with-typeobj)); nqp::bindkey($result, 'callback_args', $info); } else { nqp::bindkey($result, 'type', nqp::unbox_s(type_code_for($p.type))); } $result } # Builds the list of parameter information for a callback argument. sub param_list_for(Signature $sig, &r?, :$with-typeobj) { my Mu $arg_info := nqp::list(); my @params = $sig.params; @params.pop if &r ~~ Method && @params[*-1].name eq '%_'; for @params -> $p { nqp::push($arg_info, param_hash_for($p, :with-typeobj($with-typeobj))) } $arg_info; } # Builds a hash of type information for the specified return type. sub return_hash_for(Signature $s, &r?, :$with-typeobj) { my Mu $result := nqp::hash(); my $returns := $s.returns; nqp::bindkey($result, 'typeobj', nqp::decont($returns)) if $with-typeobj; if $returns ~~ Str { my $enc := &r.?native_call_encoded() || 'utf8'; nqp::bindkey($result, 'type', nqp::unbox_s(string_encoding_to_nci_type($enc))); nqp::bindkey($result, 'free_str', nqp::unbox_i(0)); } # TODO: If we ever want to handle function pointers returned from C, this # bit of code needs to handle that. else { nqp::bindkey($result, 'type', $returns =:= Mu ?? 'void' !! nqp::unbox_s(type_code_for($returns))); } $result } # Gets the NCI type code to use based on a given Perl 6 type. my %type_map = 'int8' => 'char', 'Bool' => 'char', 'int16' => 'short', 'int32' => 'int', 'int64' => 'longlong', 'long' => 'long', 'int' => 'long', 'longlong' => 'longlong', 'Int' => 'longlong', 'uint8' => 'uchar', 'uint16' => 'ushort', 'uint32' => 'uint', 'uint64' => 'ulonglong', 'ulonglong' => 'ulonglong', 'ulong' => 'ulong', 'uint' => 'ulong', 'num32' => 'float', 'num64' => 'double', 'longdouble' => 'longdouble', 'num' => 'double', 'Num' => 'double', 'Callable' => 'callback'; my %repr_map = 'CStruct' => 'cstruct', 'CPPStruct' => 'cppstruct', 'CPointer' => 'cpointer', 'CArray' => 'carray', 'CUnion' => 'cunion', 'VMArray' => 'vmarray', ; sub type_code_for(Mu ::T) { my $shortname = T.^shortname; return %type_map{$shortname} if %type_map{$shortname}:exists; if %repr_map{T.REPR} -> $mapped { return $mapped; } # the REPR of a Buf or Blob type object is Uninstantiable, so # needs an extra special case here that isn't covered in the # hash lookup above. return 'vmarray' if T ~~ Blob; return 'cpointer' if T ~~ Pointer; die "Unknown type {T.^name} used in native call.\n" ~ "If you want to pass a struct, be sure to use the CStruct or CPPStruct representation.\n" ~ "If you want to pass an array, be sure to use the CArray type."; } sub gen_native_symbol(Routine $r, :$cpp-name-mangler) { if $r.package.REPR eq 'CPPStruct' { $cpp-name-mangler($r, $r.?native_symbol // ($r.package.^name ~ '::' ~ $r.name)) } elsif $r.?native_call_mangled { $cpp-name-mangler($r, $r.?native_symbol // $r.name) } else { $r.?native_symbol // $r.name } } multi sub map_return_type(Mu $type) { Mu } multi sub map_return_type($type) { nqp::istype($type, Int) ?? Int !! nqp::istype($type, Num) ?? Num !! $type; } my role NativeCallSymbol[Str $name] { method native_symbol() { $name } } sub guess_library_name($lib) { my $libname; if ($lib ~~ Callable) { $libname = $lib(); } else { $libname = $lib; } if !$libname.DEFINITE { '' } elsif $libname ~~ /\.<.alpha>+$/ { $libname } elsif $libname ~~ /\.so(\.<.digit>+)+$/ { $libname } elsif $*VM.config :exists { $libname ~ $*VM.config } elsif $*VM.config :exists { if $*KERNEL.name eq 'darwin' { ($libname ~ '.' ~ $*VM.config).IO.absolute } else { $libname ~ '.' ~ $*VM.config } } elsif $*VM.config :exists { my $ext = $*VM.config; $ext ~~ s/^.*\%s//; "$libname$ext"; } elsif $*DISTRO.is-win { "{$libname}.dll"; } # TODO: more extension guessing else { "{$libname}.so"; } } my %lib; my @cpp-name-mangler = &NativeCall::Compiler::MSVC::mangle_cpp_symbol, &NativeCall::Compiler::GNU::mangle_cpp_symbol, ; sub guess-name-mangler(Routine $r, Str $libname) { if $r.package.REPR eq 'CPPStruct' { my $sym = $r.?native_symbol // ($r.package.^name ~ '::' ~ $r.name); for @cpp-name-mangler -> &mangler { return &mangler if try cglobal($libname, mangler($r, $sym), Pointer) } die "Don't know how to mangle symbol '$sym' for library '$libname'" } elsif $r.?native_call_mangled { my $sym = $r.?native_symbol // $r.name; for @cpp-name-mangler -> &mangler { return &mangler if try cglobal($libname, mangler($r, $sym), Pointer) } die "Don't know how to mangle symbol '$sym' for library '$libname'" } } # This role is mixed in to any routine that is marked as being a # native call. my role Native[Routine $r, $libname where Str|Callable] { has int $!setup; has native_callsite $!call is box_target; has Mu $!rettype; has $!cpp-name-mangler; method !setup() { my $guessed_libname = guess_library_name($libname); $!cpp-name-mangler = %lib{$guessed_libname} // (%lib{$guessed_libname} = guess-name-mangler($r, $guessed_libname)); my Mu $arg_info := param_list_for($r.signature, $r); my str $conv = self.?native_call_convention || ''; nqp::buildnativecall(self, nqp::unbox_s($guessed_libname), # library name nqp::unbox_s(gen_native_symbol($r, :$!cpp-name-mangler)), # symbol to call nqp::unbox_s($conv), # calling convention $arg_info, return_hash_for($r.signature, $r)); $!setup = 1; $!rettype := nqp::decont(map_return_type($r.returns)); } method CALL-ME(|args) { self!setup unless $!setup; my Mu $args := nqp::getattr(nqp::decont(args), Capture, '$!list'); if nqp::elems($args) != $r.signature.arity { X::TypeCheck::Argument.new( :objname($.name), :arguments(args.list.map(*.^name)) :signature(" Expected: " ~ try $r.signature.perl), ).throw } nqp::nativecall($!rettype, self, $args) } } # Role for carrying extra calling convention information. my role NativeCallingConvention[$name] { method native_call_convention() { $name }; } # Role for carrying extra string encoding information. my role NativeCallEncoded[$name] { method native_call_encoded() { $name }; } my role NativeCallMangled[$name] { method native_call_mangled() { $name } } multi sub postcircumfix:<[ ]>(CArray:D \array, $pos) is export(:DEFAULT, :types) { $pos ~~ Iterable ?? $pos.map: { array.AT-POS($_) } !! array.AT-POS($pos); } multi sub postcircumfix:<[ ]>(CArray:D \array, *@pos) is export(:DEFAULT, :types) { @pos.map: { array.AT-POS($_) }; } multi trait_mod:(Routine $r, :$symbol!) is export(:DEFAULT, :traits) { $r does NativeCallSymbol[$symbol]; } # Specifies that the routine is actually a native call, into the # current executable (platform specific) or into a named library multi trait_mod:(Routine $r, :$native!) is export(:DEFAULT, :traits) { $r does Native[$r, $native === True ?? Str !! $native]; } # Specifies the calling convention to use for a native call. multi trait_mod:(Routine $r, :$nativeconv!) is export(:DEFAULT, :traits) { $r does NativeCallingConvention[$nativeconv]; } # Ways to specify how to marshall strings. multi trait_mod:(Parameter $p, :$encoded!) is export(:DEFAULT, :traits) { $p does NativeCallEncoded[$encoded]; } multi trait_mod:(Routine $p, :$encoded!) is export(:DEFAULT, :traits) { $p does NativeCallEncoded[$encoded]; } multi trait_mod:(Routine $p, :$mangled!) is export(:DEFAULT, :traits) { $p does NativeCallMangled[$mangled === True ?? 'C++' !! $mangled]; } role ExplicitlyManagedString { has $.cstr is rw; } multi explicitly-manage(Str $x, :$encoding = 'utf8') is export(:DEFAULT, :utils) { $x does ExplicitlyManagedString; my $class = class CStr is repr('CStr') { method encoding() { $encoding; } }; $x.cstr = nqp::box_s(nqp::unbox_s($x), nqp::decont($class)); } role CPPConst { method cpp-const() { 1 } } multi trait_mod:(Parameter $p, :$cpp-const!) is export(:DEFAULT, :traits) { $p does CPPConst; } role CPPRef { method cpp-ref() { 1 } } multi trait_mod:(Parameter $p, :$cpp-ref!) is export(:DEFAULT, :traits) { $p does CPPRef; } multi refresh($obj) is export(:DEFAULT, :utils) { nqp::nativecallrefresh($obj); 1; } sub nativecast($target-type, $source) is export(:DEFAULT) { nqp::nativecallcast(nqp::decont($target-type), nqp::decont(map_return_type($target-type)), nqp::decont($source)); } sub nativesizeof($obj) is export(:DEFAULT) { nqp::nativecallsizeof($obj) } sub cglobal($libname, $symbol, $target-type) is export is rw { Proxy.new( FETCH => -> $ { nqp::nativecallglobal( nqp::unbox_s(guess_library_name($libname)), nqp::unbox_s($symbol), nqp::decont($target-type), nqp::decont(map_return_type($target-type))) }, STORE => -> | { die "Writing to C globals NYI" } ) } } sub EXPORT(|) { use NQPHLL:from; my role HAS-decl-grammar { # This is a direct copy of scope_declarator:sym, besides the uppercase spelling. token scope_declarator:sym { :my $*LINE_NO := HLL::Compiler.lineof(self.orig(), self.from(), :cache(1)); :my $*HAS_SELF := 'partial'; :my $*ATTR_INIT_BLOCK; } } my role HAS-decl-actions { method scope_declarator:sym(Mu $/) { # my $scoped := $.ast; my Mu $scoped := nqp::atkey(nqp::findmethod($/, 'hash')($/), 'scoped').ast; my Mu $attr := $scoped.ann('metaattr'); if $attr.package.REPR ne 'CStruct' && $attr.package.REPR ne 'CPPStruct' && $attr.package.REPR ne 'CUnion' { die "Can only use HAS-scoped attributes in classes with repr CStruct, CPPStruct and CUnion, not " ~ $attr.package.REPR; } if nqp::objprimspec($attr.type) != 0 { warn "Useless use of HAS scope on an attribute with type { $attr.type.^name }."; } # Mark $attr as inlined, that's why we do all this. nqp::bindattr_i(nqp::decont($attr), $attr.WHAT, '$!inlined', 1); # make $scoped nqp::bindattr(nqp::decont($/), $/.WHAT, '$!made', $scoped); } } my Mu $MAIN-grammar := nqp::atkey(%*LANG, 'MAIN'); my Mu $MAIN-actions := nqp::atkey(%*LANG, 'MAIN-actions'); nqp::bindkey(%*LANG, 'MAIN', $MAIN-grammar.HOW.mixin($MAIN-grammar, HAS-decl-grammar)); nqp::bindkey(%*LANG, 'MAIN-actions', $MAIN-actions.HOW.mixin($MAIN-actions, HAS-decl-actions)); {} } # vim:ft=perl6 rakudo-2015.11/lib/NativeCall/Compiler/GNU.pm000644 000765 000024 00000003617 12600026747 022465 0ustar00williamcoledastaff000000 000000 unit class NativeCall::Compiler::GNU; use NativeCall::Types; our sub mangle_cpp_symbol(Routine $r, $symbol) { $r.signature.set_returns($r.package) if $r.name eq 'new' && !$r.signature.has_returns && $r.package !~~ GLOBAL; my $mangled = '_Z' ~ ($r.package.REPR eq 'CPPStruct' ?? 'N' !! '') ~ $symbol.split('::').map({$_ eq 'new' ?? 'C1' !! $_.chars ~ $_}).join('') ~ ($r.package.REPR eq 'CPPStruct' ?? 'E' !! ''); my @params = $r.signature.params; if $r ~~ Method { @params.shift; @params.pop if @params[*-1].name eq '%_'; } my $params = join '', @params.map: { my $R = $_.?cpp-ref ?? 'R' !! ''; # reference my $P = .rw ?? 'P' !! ''; # pointer my $K = ($R || $P) && $_.?cpp-const ?? 'K' !! ''; # const cpp_param_letter(.type, :$R, :$P, :$K) }; $mangled ~= $params || 'v'; } sub cpp_param_letter($type, :$R = '', :$P = '', :$K = '') { given $type { when NativeCall::Types::void { $R ~ $P ~ $K ~ 'v' } when Bool { $R ~ $P ~ $K ~ 'b' } when int8 { $R ~ $P ~ $K ~ 'c' } when int16 { $R ~ $P ~ $K ~ 's' } when int32 { $R ~ $P ~ $K ~ 'i' } when NativeCall::Types::long { $R ~ $P ~ $K ~ 'l' } when NativeCall::Types::longlong { $R ~ $P ~ $K ~ 'x' } when num32 { $R ~ $P ~ $K ~ 'f' } when num64 { $R ~ $P ~ $K ~ 'd' } when Str { 'Pc' } when NativeCall::Types::CArray | NativeCall::Types::Pointer { 'P' ~ $K ~ cpp_param_letter(.of); } default { my $name = .^name; $R ~ $P ~ $K ~ $name.chars ~ $name; } } } rakudo-2015.11/lib/NativeCall/Compiler/MSVC.pm000644 000765 000024 00000005154 12600026600 022566 0ustar00williamcoledastaff000000 000000 unit class NativeCall::Compiler::MSVC; use NativeCall::Types; our sub mangle_cpp_symbol(Routine $r, $symbol) { $r.signature.set_returns($r.package) if $r.name eq 'new' && !$r.signature.has_returns && $r.package !~~ GLOBAL; my $mangled = '?'; if $r ~~ Method { $mangled ~= $symbol.split('::').reverse.map({$_ eq 'new' ?? '?0' !! "$_@"}).join('') ~ '@' ~ ($r.name eq 'new' ?? 'QE' !! 'UE'); } else { $mangled ~= $symbol.split('::').reverse.map({"$_@"}).join('') ~ '@' ~ 'Y' ~ 'A' # http://en.wikipedia.org/wiki/Visual_C%2B%2B_name_mangling#Function_Property ~ ($r.signature.has_returns ?? cpp_param_letter($r.returns) !! 'X'); } my @params = $r.signature.params; if $r ~~ Method { @params.shift; @params.pop if @params[*-1].name eq '%_'; } my $params = join '', @params.map: { my $R = ''; # reference my $P = .rw ?? 'PE' !! ''; # pointer my $K = $P ?? ($_.?cpp-const ?? 'B' !! 'A') !! ''; # const cpp_param_letter(.type, :$R, :$P, :$K) }; if $r ~~ Method { $mangled ~= 'AA'; $mangled ~= $r.signature.has_returns && $r.name ne 'new' ?? cpp_param_letter($r.returns) !! ''; $mangled ~= $params; $mangled ~= '@' if $params || $r.name eq 'new'; $mangled ~= $params ?? 'Z' !! 'XZ'; } else { $mangled ~= $params || 'X'; $mangled ~= '@' if $r.package.REPR eq 'CPPStruct'; $mangled ~= 'Z'; } $mangled } sub cpp_param_letter($type, :$R = '', :$P = '', :$K = '') { given $type { when NativeCall::Types::void { $R ~ $K ~ 'X' } when Bool { $R ~ $K ~ '_N' } when int8 { $R ~ $K ~ 'D' } when int16 { $R ~ $K ~ 'F' } when int32 { $P ~ $K ~ 'H' } when NativeCall::Types::long { $R ~ $K ~ 'J' } when NativeCall::Types::longlong { $R ~ '_J' } when num32 { $R ~ $K ~ 'M' } when num64 { $R ~ $K ~ 'N' } when Str { 'PEAD' } when NativeCall::Types::CArray { 'QEA' ~ cpp_param_letter(.of); } when NativeCall::Types::Pointer { 'PEA' ~ cpp_param_letter(.of); } default { my $name = .^name; $P ~ $K ~ $name.chars ~ $name; } } } rakudo-2015.11/lib/NativeCall/Types.pm000644 000765 000024 00000020144 12600026600 021344 0ustar00williamcoledastaff000000 000000 use nqp; unit module NativeCall::Types; our native long is Int is ctype("long") is repr("P6int") { }; our native longlong is Int is ctype("longlong") is repr("P6int") { }; our native ulong is Int is ctype("long") is unsigned is repr("P6int") { }; our native ulonglong is Int is ctype("longlong") is unsigned is repr("P6int") { }; our class void is repr('Uninstantiable') { }; # Expose a Pointer class for working with raw pointers. our class Pointer is repr('CPointer') { }; # need to introduce the roles in there in an augment, because you can't # inherit from types that haven't been properly composed. use MONKEY-TYPING; augment class Pointer { method of() { void } method ^name($) { 'Pointer' } multi method new() { self.CREATE() } multi method new(int $addr) { nqp::box_i($addr, ::?CLASS) } multi method new(Int $addr) { nqp::box_i(nqp::unbox_i(nqp::decont($addr)), ::?CLASS) } method Numeric(::?CLASS:D:) { self.Int } method Int(::?CLASS:D:) { nqp::p6box_i(nqp::unbox_i(nqp::decont(self))) } method deref(::?CLASS:D \ptr:) { nativecast(void, ptr) } multi method gist(::?CLASS:U:) { '(' ~ self.^name ~ ')' } multi method gist(::?CLASS:D:) { if self.Int -> $addr { self.^name ~ '<' ~ $addr.fmt('%#x') ~ '>' } else { self.^name ~ '' } } multi method perl(::?CLASS:U:) { self.^name } multi method perl(::?CLASS:D:) { self.^name ~ '.new(' ~ self.Int ~ ')' } my role TypedPointer[::TValue = void] is Pointer is repr('CPointer') { method of() { TValue } # method ^name($obj) { 'Pointer[' ~ TValue.^name ~ ']' } method deref(::?CLASS:D \ptr:) { nativecast(TValue, ptr) } } method ^parameterize($, Mu:U \t) { die "A typed pointer can only hold integers, numbers, strings, CStructs, CPointers or CArrays (not {t.^name})" unless t ~~ Int|Num|Bool || t === Str|void || t.REPR eq any ; my \typed := TypedPointer[t]; typed.^inheritalize; } } # CArray class, used to represent C arrays. our class CArray is repr('CArray') is array_type(Pointer) { }; # need to introduce the roles in there in an augment, because you can't # inherit from types that haven't been properly composed. use MONKEY-TYPING; augment class CArray { method AT-POS(CArray:D: $pos) { die "CArray cannot be used without a type" } my role IntTypedCArray[::TValue] does Positional[TValue] is CArray is repr('CArray') is array_type(TValue) { multi method AT-POS(::?CLASS:D \arr: $pos) is rw { Proxy.new: FETCH => method () { nqp::p6box_i(nqp::atpos_i(nqp::decont(arr), nqp::unbox_i($pos.Int))) }, STORE => method (int $v) { nqp::bindpos_i(nqp::decont(arr), nqp::unbox_i($pos.Int), $v); self } } multi method AT-POS(::?CLASS:D \arr: int $pos) is rw { Proxy.new: FETCH => method () { nqp::p6box_i(nqp::atpos_i(nqp::decont(arr), $pos)) }, STORE => method (int $v) { nqp::bindpos_i(nqp::decont(arr), $pos, $v); self } } multi method ASSIGN-POS(::?CLASS:D \arr: int $pos, int $assignee) { nqp::bindpos_i(nqp::decont(arr), $pos, $assignee); } multi method ASSIGN-POS(::?CLASS:D \arr: Int $pos, int $assignee) { nqp::bindpos_i(nqp::decont(arr), nqp::unbox_i($pos), $assignee); } multi method ASSIGN-POS(::?CLASS:D \arr: Int $pos, Int $assignee) { nqp::bindpos_i(nqp::decont(arr), nqp::unbox_i($pos), nqp::unbox_i($assignee)); } multi method ASSIGN-POS(::?CLASS:D \arr: int $pos, Int $assignee) { nqp::bindpos_i(nqp::decont(arr), $pos, nqp::unbox_i($assignee)); } } my role NumTypedCArray[::TValue] does Positional[TValue] is CArray is repr('CArray') is array_type(TValue) { multi method AT-POS(::?CLASS:D \arr: $pos) is rw { Proxy.new: FETCH => method () { nqp::p6box_n(nqp::atpos_n(nqp::decont(arr), nqp::unbox_i($pos.Int))) }, STORE => method (num $v) { nqp::bindpos_n(nqp::decont(arr), nqp::unbox_i($pos.Int), $v); self } } multi method AT-POS(::?CLASS:D \arr: int $pos) is rw { Proxy.new: FETCH => method () { nqp::p6box_n(nqp::atpos_n(nqp::decont(arr), $pos)) }, STORE => method (num $v) { nqp::bindpos_n(nqp::decont(arr), $pos, $v); self } } multi method ASSIGN-POS(::?CLASS:D \arr: int $pos, num $assignee) { nqp::bindpos_n(nqp::decont(arr), $pos, $assignee); } multi method ASSIGN-POS(::?CLASS:D \arr: Int $pos, num $assignee) { nqp::bindpos_n(nqp::decont(arr), nqp::unbox_i($pos), $assignee); } multi method ASSIGN-POS(::?CLASS:D \arr: Int $pos, Num $assignee) { nqp::bindpos_n(nqp::decont(arr), nqp::unbox_i($pos), nqp::unbox_n($assignee)); } multi method ASSIGN-POS(::?CLASS:D \arr: int $pos, Num $assignee) { nqp::bindpos_n(nqp::decont(arr), $pos, nqp::unbox_n($assignee)); } } my role TypedCArray[::TValue] does Positional[TValue] is CArray is repr('CArray') is array_type(TValue) { multi method AT-POS(::?CLASS:D \arr: $pos) is rw { Proxy.new: FETCH => method () { nqp::atpos(nqp::decont(arr), nqp::unbox_i($pos.Int)) }, STORE => method ($v) { nqp::bindpos(nqp::decont(arr), nqp::unbox_i($pos.Int), nqp::decont($v)); self } } multi method AT-POS(::?CLASS:D \arr: int $pos) is rw { Proxy.new: FETCH => method () { nqp::atpos(nqp::decont(arr), $pos) }, STORE => method ($v) { nqp::bindpos(nqp::decont(arr), $pos, nqp::decont($v)); self } } multi method ASSIGN-POS(::?CLASS:D \arr: int $pos, \assignee) { nqp::bindpos(nqp::decont(arr), $pos, nqp::decont(assignee)); } multi method ASSIGN-POS(::?CLASS:D \arr: Int $pos, \assignee) { nqp::bindpos(nqp::decont(arr), nqp::unbox_i($pos), nqp::decont(assignee)); } } method ^parameterize($, Mu:U \t) { my $typed; if t ~~ Int { $typed := IntTypedCArray[t.WHAT]; } elsif t ~~ Num { $typed := NumTypedCArray[t.WHAT]; } else { die "A C array can only hold integers, numbers, strings, CStructs, CPointers or CArrays (not {t.^name})" unless t === Str || t.REPR eq 'CStruct' | 'CPPStruct' | 'CUnion' | 'CPointer' | 'CArray'; $typed := TypedCArray[t]; } $typed.^inheritalize(); } method elems { nqp::elems(self) } method list { do for ^self.elems { self.AT-POS($_) } } multi method new(*@values) { nextsame unless @values; my $result := self.new(); my int $n = @values.elems; my int $i; $result.ASSIGN-POS($n - 1, @values.AT-POS($n - 1)); while $i < $n { $result.ASSIGN-POS($i, @values.AT-POS($i)); $i = $i + 1; } $result; } } # duplicated code from NativeCall.pm to support Pointer.deref multi sub map_return_type(Mu $type) { Mu } multi sub map_return_type($type) { nqp::istype($type, Int) ?? Int !! nqp::istype($type, Num) ?? Num !! $type; } sub nativecast($target-type, $source) { nqp::nativecallcast(nqp::decont($target-type), nqp::decont(map_return_type($target-type)), nqp::decont($source)); } rakudo-2015.11/lib/Pod/To/Text.pm000644 000765 000024 00000007470 12603020567 020266 0ustar00williamcoledastaff000000 000000 unit class Pod::To::Text; method render($pod) { pod2text($pod) } my &colored; if %*ENV { &colored = try { EVAL q{ use Terminal::ANSIColor; &colored } } // sub ($text, $color) { $text } } else { &colored = sub ($text, $color) { $text } } sub pod2text($pod) is export { given $pod { when Pod::Heading { heading2text($pod) } when Pod::Block::Code { code2text($pod) } when Pod::Block::Named { named2text($pod) } when Pod::Block::Para { twrap( $pod.contents.map({pod2text($_)}).join("") ) } when Pod::Block::Table { table2text($pod) } when Pod::Block::Declarator { declarator2text($pod) } when Pod::Item { item2text($pod).indent(2) } when Pod::FormattingCode { formatting2text($pod) } when Positional { $pod.map({pod2text($_)}).join("\n\n")} when Pod::Block::Comment { '' } when Pod::Config { '' } default { $pod.Str } } } sub heading2text($pod) { given $pod.level { when 1 { pod2text($pod.contents) } when 2 { ' ' ~ pod2text($pod.contents) } default { ' ' ~ pod2text($pod.contents) } } } sub code2text($pod) { " " ~ $pod.contents>>.&pod2text.subst(/\n/, "\n ", :g) } sub item2text($pod) { '* ' ~ pod2text($pod.contents).chomp.chomp } sub named2text($pod) { given $pod.name { when 'pod' { pod2text($pod.contents) } when 'para' { para2text($pod.contents[0]) } when 'defn' { pod2text($pod.contents[0]) ~ "\n" ~ pod2text($pod.contents[1..*-1]) } when 'config' { } when 'nested' { } default { $pod.name ~ "\n" ~ pod2text($pod.contents) } } } sub para2text($pod) { twine2text($pod.contents) } sub table2text($pod) { my @rows = $pod.contents; @rows.unshift($pod.headers.item) if $pod.headers; my @maxes; for 0..(@rows[1].elems - 1) -> $i { @maxes.push([max] @rows.map({ $_[$i].chars })); } my $ret; if $pod.config { $ret = $pod.config ~ "\n" } for @rows -> $row { for 0..($row.elems - 1) -> $i { $ret ~= $row[$i].fmt("%-{@maxes[$i]}s") ~ " "; } $ret ~= "\n"; } return $ret; } sub declarator2text($pod) { next unless $pod.WHEREFORE.WHY; my $what = do given $pod.WHEREFORE { when Method { my @params=$_.signature.params[1..*]; @params.pop if @params[*-1].name eq '%_'; 'method ' ~ $_.name ~ signature2text(@params) } when Sub { 'sub ' ~ $_.name ~ signature2text($_.signature.params) } when .HOW ~~ Metamodel::ClassHOW { 'class ' ~ $_.perl } when .HOW ~~ Metamodel::ModuleHOW { 'module ' ~ $_.perl } when .HOW ~~ Metamodel::PackageHOW { 'package ' ~ $_.perl } default { '' } } return "$what\n{$pod.WHEREFORE.WHY.contents}" } sub signature2text($params) { $params.elems ?? "(\n\t" ~ $params.map({ $_.perl }).join(", \n\t") ~ "\n)" !! "()"; } my %formats = C => "bold", L => "underline", D => "underline", R => "inverse" ; sub formatting2text($pod) { my $text = $pod.contents>>.&pod2text.join; if $pod.type ~~ %formats { return colored($text, %formats{$pod.type}); } $text } sub twine2text($twine) { return '' unless $twine.elems; my $r = $twine[0]; for $twine[1..*] -> $f, $s { $r ~= twine2text($f.contents); $r ~= $s; } return $r; } sub twrap($text is copy, :$wrap=75 ) { $text ~~ s:g/(. ** {$wrap} <[\s]>*)\s+/$0\n/; return $text } # vim: ft=perl6 rakudo-2015.11/lib/Test.pm000644 000765 000024 00000044314 12613750540 017155 0ustar00williamcoledastaff000000 000000 use nqp; unit module Test; # Copyright (C) 2007 - 2014 The Perl Foundation. # settable from outside my $perl6_test_times = ? %*ENV; # global state my @vars; my $indents = ""; # variables to keep track of our tests my $num_of_tests_run; my $num_of_tests_failed; my $todo_upto_test_num; my $todo_reason; my $num_of_tests_planned; my $no_plan; my $die_on_fail; my num $time_before; my num $time_after; # Output should always go to real stdout/stderr, not to any dynamic overrides. my $output; my $failure_output; my $todo_output; ## If done_testing hasn't been run when we hit our END block, we need to know ## so that it can be run. This allows compatibility with old tests that use ## plans and don't call done_testing. my $done_testing_has_been_run = 0; # make sure we have initializations _init_vars(); sub _init_io { $output = $PROCESS::OUT; $failure_output = $PROCESS::ERR; $todo_output = $PROCESS::OUT; } ## test functions our sub output is rw { $output } our sub failure_output is rw { $failure_output } our sub todo_output is rw { $todo_output } # you can call die_on_fail; to turn it on and die_on_fail(0) to turn it off sub die_on_fail($fail=1) { $die_on_fail = $fail; } # "plan 'no_plan';" is now "plan *;" # It is also the default if nobody calls plan at all multi sub plan($number_of_tests) is export { _init_io() unless $output; if $number_of_tests ~~ ::Whatever { $no_plan = 1; } else { $num_of_tests_planned = $number_of_tests; $no_plan = 0; $output.say: $indents ~ '1..' ~ $number_of_tests; } # Get two successive timestamps to say how long it takes to read the # clock, and to let the first test timing work just like the rest. # These readings should be made with the expression now.to-posix[0], # but its execution time when tried in the following two lines is a # lot slower than the non portable nqp::time_n. $time_before = nqp::time_n; $time_after = nqp::time_n; $output.say: $indents ~ '# between two timestamps ' ~ ceiling(($time_after-$time_before)*1_000_000) ~ ' microseconds' if $perl6_test_times; # Take one more reading to serve as the begin time of the first test $time_before = nqp::time_n; } multi sub pass($desc = '') is export { $time_after = nqp::time_n; proclaim(1, $desc); $time_before = nqp::time_n; } multi sub ok(Mu $cond, $desc = '') is export { $time_after = nqp::time_n; my $ok = proclaim(?$cond, $desc); $time_before = nqp::time_n; $ok; } multi sub nok(Mu $cond, $desc = '') is export { $time_after = nqp::time_n; my $ok = proclaim(!$cond, $desc); $time_before = nqp::time_n; $ok; } multi sub is(Mu $got, Mu:U $expected, $desc = '') is export { $time_after = nqp::time_n; my $ok; if $got.defined { # also hack to deal with Failures $ok = proclaim(False, $desc); diag "expected: ($expected.^name())"; diag " got: '$got'"; } else { my $test = $got === $expected; $ok = proclaim(?$test, $desc); if !$test { diag "expected: ($expected.^name())"; diag " got: ($got.^name())"; } } $time_before = nqp::time_n; $ok; } multi sub is(Mu $got, Mu:D $expected, $desc = '') is export { $time_after = nqp::time_n; my $ok; if $got.defined { # also hack to deal with Failures my $test = $got eq $expected; $ok = proclaim(?$test, $desc); if !$test { if try [eq] ($got, $expected)>>.Str>>.subst(/\s/, '', :g) { # only white space differs, so better show it to the user diag "expected: {$expected.perl}"; diag " got: {$got.perl}"; } else { diag "expected: '$expected'"; diag " got: '$got'"; } } } else { $ok = proclaim(False, $desc); diag "expected: '$expected'"; diag " got: ($got.^name())"; } $time_before = nqp::time_n; $ok; } multi sub isnt(Mu $got, Mu:U $expected, $desc = '') is export { $time_after = nqp::time_n; my $ok; if $got.defined { # also hack to deal with Failures $ok = proclaim(True, $desc); } else { my $test = $got !=== $expected; $ok = proclaim(?$test, $desc); if !$test { diag "twice: ($got.^name())"; } } $time_before = nqp::time_n; $ok; } multi sub isnt(Mu $got, Mu:D $expected, $desc = '') is export { $time_after = nqp::time_n; my $ok; if $got.defined { # also hack to deal with Failures my $test = $got ne $expected; $ok = proclaim(?$test, $desc); if !$test { diag "twice: '$got'"; } } else { $ok = proclaim(True, $desc); } $time_before = nqp::time_n; $ok; } multi sub cmp-ok(Mu $got, $op, Mu $expected, $desc = '') is export { $time_after = nqp::p6box_n(nqp::time_n); $got.defined; # Hack to deal with Failures my $ok; if $op ~~ Callable ?? $op !! try EVAL "&infix:<$op>" -> $matcher { $ok = proclaim(?$matcher($got,$expected), $desc); if !$ok { diag "expected: '{$expected // $expected.^name}'"; diag " matcher: '$matcher'"; diag " got: '$got'"; } } else { $ok = proclaim(False, $desc); diag "Could not use '$op' as a comparator"; } $time_before = nqp::time_n; $ok; } multi sub is_approx(Mu $got, Mu $expected, $desc = '') is export { $time_after = nqp::p6box_n(nqp::time_n); my $tol = $expected.abs < 1e-6 ?? 1e-5 !! $expected.abs * 1e-6; my $test = ($got - $expected).abs <= $tol; my $ok = proclaim(?$test, $desc); unless $test { diag("expected: $expected"); diag("got: $got"); } $time_before = nqp::time_n; $ok; } multi sub is-approx(Numeric $got, Numeric $expected, $desc = '') is export { is-approx($got, $expected, 1e-6, $desc); } multi sub is-approx(Numeric $got, Numeric $expected, Numeric $tol, $desc = '') is export { $time_after = nqp::p6box_n(nqp::time_n); die "Tolerance must be a positive number greater than zero" unless $tol > 0; my $abs-diff = ($got - $expected).abs; my $abs-max = max($got.abs, $expected.abs); my $rel-diff = $abs-max == 0 ?? 0 !! $abs-diff/$abs-max; my $test = $rel-diff <= $tol; my $ok = proclaim(?$test, $desc); unless $test { diag("expected: $expected"); diag("got: $got"); } $time_before = nqp::p6box_n(nqp::time_n); $ok; } multi sub is-approx(Numeric $got, Numeric $expected, Numeric :$rel_tol = 1e-6, Numeric :$abs_tol = 0, :$desc = '') is export { $time_after = nqp::p6box_n(nqp::time_n); die "Relative tolerance must be a positive number greater than zero" unless $rel_tol > 0; die "Absolute tolerance must be a positive number greater than zero" unless $abs_tol > 0; my $abs-diff = ($got - $expected).abs; my $test = (($abs-diff <= ($rel_tol * $expected).abs) && ($abs-diff <= ($rel_tol * $got).abs) || ($abs-diff <= $abs_tol)); my $ok = proclaim(?$test, $desc); unless $test { diag("expected: $expected"); diag("got: $got"); } $time_before = nqp::time_n; $ok; } multi sub todo($reason, $count = 1) is export { $time_after = nqp::time_n; $todo_upto_test_num = $num_of_tests_run + $count; $todo_reason = '# TODO ' ~ $reason.subst(:g, '#', '\\#'); $time_before = nqp::time_n; } multi sub skip() { $time_after = nqp::time_n; proclaim(1, "# SKIP"); $time_before = nqp::time_n; } multi sub skip($reason, $count = 1) is export { $time_after = nqp::time_n; die "skip() was passed a non-numeric number of tests. Did you get the arguments backwards?" if $count !~~ Numeric; my $i = 1; while $i <= $count { proclaim(1, "# SKIP " ~ $reason); $i = $i + 1; } $time_before = nqp::time_n; } sub skip-rest($reason = '') is export { $time_after = nqp::p6box_n(nqp::time_n); die "A plan is required in order to use skip-rest" if $no_plan; skip($reason, $num_of_tests_planned - $num_of_tests_run); $time_before = nqp::time_n; } sub subtest(&subtests, $desc = '') is export { _push_vars(); _init_vars(); $indents ~= " "; subtests(); done-testing() if !$done_testing_has_been_run; my $status = $num_of_tests_failed == 0 && $num_of_tests_planned == $num_of_tests_run; _pop_vars; $indents .= chop(4); proclaim($status,$desc); } sub diag(Mu $message) is export { _init_io() unless $output; my $is_todo = $num_of_tests_run <= $todo_upto_test_num; my $out = $is_todo ?? $todo_output !! $failure_output; $time_after = nqp::time_n; my $str-message = $message.Str.subst(rx/^^/, '# ', :g); $str-message .= subst(rx/^^'#' \s+ $$/, '', :g); $out.say: $indents ~ $str-message; $time_before = nqp::time_n; } multi sub flunk($reason) is export { $time_after = nqp::time_n; my $ok = proclaim(0, $reason); $time_before = nqp::time_n; $ok; } multi sub isa-ok(Mu $var, Mu $type, $msg = ("The object is-a '" ~ $type.perl ~ "'")) is export { $time_after = nqp::p6box_n(nqp::time_n); my $ok = proclaim($var.isa($type), $msg) or diag('Actual type: ' ~ $var.^name); $time_before = nqp::time_n; $ok; } multi sub does-ok(Mu $var, Mu $type, $msg = ("The object does role '" ~ $type.perl ~ "'")) is export { $time_after = nqp::p6box_n(nqp::time_n); my $ok = proclaim($var.does($type), $msg) or diag([~] 'Type: ', $var.^name, " doesn't do role ", $type.perl); $time_before = nqp::time_n; $ok; } multi sub can-ok(Mu $var, Str $meth, $msg = ( ($var.defined ?? "An object of type '" !! "The type '" ) ~ $var.WHAT.perl ~ "' can do the method '$meth'") ) is export { $time_after = nqp::p6box_n(nqp::time_n); my $ok = proclaim($var.^can($meth), $msg); $time_before = nqp::time_n; $ok; } multi sub like(Str $got, Regex $expected, $desc = '') is export { $time_after = nqp::time_n; $got.defined; # Hack to deal with Failures my $test = $got ~~ $expected; my $ok = proclaim(?$test, $desc); if !$test { diag sprintf " expected: '%s'", $expected.perl; diag " got: '$got'"; } $time_before = nqp::time_n; $ok; } multi sub unlike(Str $got, Regex $expected, $desc = '') is export { $time_after = nqp::time_n; $got.defined; # Hack to deal with Failures my $test = !($got ~~ $expected); my $ok = proclaim(?$test, $desc); if !$test { diag sprintf " expected: '%s'", $expected.perl; diag " got: '$got'"; } $time_before = nqp::time_n; $ok; } multi sub use-ok(Str $code, $msg = ("The module can be use-d ok")) is export { $time_after = nqp::time_n; try { EVAL ( "use $code" ); } my $ok = proclaim((not defined $!), $msg) or diag($!); $time_before = nqp::time_n; $ok; } multi sub dies-ok(Callable $code, $reason = '') is export { $time_after = nqp::p6box_n(nqp::time_n); my $death = 1; try { $code(); $death = 0; } my $ok = proclaim( $death, $reason ); $time_before = nqp::time_n; $ok; } multi sub lives-ok(Callable $code, $reason = '') is export { $time_after = nqp::p6box_n(nqp::time_n); try { $code(); } my $ok = proclaim((not defined $!), $reason) or diag($!); $time_before = nqp::time_n; $ok; } multi sub eval-dies-ok(Str $code, $reason = '') is export { $time_after = nqp::p6box_n(nqp::time_n); my $ee = eval_exception($code); my $ok = proclaim( $ee.defined, $reason ); $time_before = nqp::time_n; $ok; } multi sub eval-lives-ok(Str $code, $reason = '') is export { $time_after = nqp::p6box_n(nqp::time_n); my $ee = eval_exception($code); my $ok = proclaim((not defined $ee), $reason) or diag("Error: $ee"); $time_before = nqp::time_n; $ok; } multi sub is-deeply(Mu $got, Mu $expected, $reason = '') is export { $time_after = nqp::p6box_n(nqp::time_n); my $test = _is_deeply( $got, $expected ); my $ok = proclaim($test, $reason); if !$test { my $got_perl = try { $got.perl }; my $expected_perl = try { $expected.perl }; if $got_perl.defined && $expected_perl.defined { diag "expected: $expected_perl"; diag " got: $got_perl"; } } $time_before = nqp::time_n; $ok; } sub throws-like($code, $ex_type, $reason?, *%matcher) is export { subtest { plan 2 + %matcher.keys.elems; my $msg; if $code ~~ Callable { $msg = 'code dies'; $code() } else { $msg = "'$code' died"; EVAL $code, context => CALLER::CALLER::CALLER::CALLER::; } flunk $msg; skip 'Code did not die, can not check exception', 1 + %matcher.elems; CATCH { default { pass $msg; my $type_ok = $_ ~~ $ex_type; ok $type_ok , "right exception type ({$ex_type.^name})"; if $type_ok { for %matcher.kv -> $k, $v { my $got is default(Nil) = $_."$k"(); my $ok = $got ~~ $v,; ok $ok, ".$k matches $v.gist()"; unless $ok { diag "Expected: " ~ ($v ~~ Str ?? $v !! $v.perl); diag "Got: $got"; } } } else { diag "Expected: {$ex_type.gist}"; diag "Got: {$_.WHAT.gist}"; diag "Exception message: $_.message()"; skip 'wrong exception type', %matcher.elems; } } } }, $reason // "did we throws-like {$ex_type.^name}?"; } sub _is_deeply(Mu $got, Mu $expected) { $got eqv $expected; } ## 'private' subs sub eval_exception($code) { try { EVAL ($code); } $!; } sub proclaim($cond, $desc) { _init_io() unless $output; # exclude the time spent in proclaim from the test time $num_of_tests_run = $num_of_tests_run + 1; my $tap = $indents; unless $cond { $tap ~= "not "; unless $num_of_tests_run <= $todo_upto_test_num { $num_of_tests_failed = $num_of_tests_failed + 1 } } if $todo_reason and $num_of_tests_run <= $todo_upto_test_num { # TAP parsers do not like '#' in the description, they'd miss the '# TODO' $tap ~= "ok $num_of_tests_run - " ~ $desc.subst('#', '', :g) ~ $todo_reason; } else { $tap ~= "ok $num_of_tests_run - $desc"; } $output.say: $tap; $output.say: $indents ~ "# t=" ~ ceiling(($time_after-$time_before)*1_000_000) if $perl6_test_times; unless $cond { my $caller; my $level = 2; # sub proclaim is not called directly, so 2 is minimum level repeat until !$?FILE.ends-with($caller.file) { $caller = callframe($level++); } if $desc ne '' { diag "\nFailed test '$desc'\nat {$caller.file} line {$caller.line}"; } else { diag "\nFailed test at {$caller.file} line {$caller.line}"; } } if !$cond && $die_on_fail && !$todo_reason { die "Test failed. Stopping test"; } # must clear this between tests if $todo_upto_test_num == $num_of_tests_run { $todo_reason = '' } $cond; } sub done-testing() is export { _init_io() unless $output; $done_testing_has_been_run = 1; if $no_plan { $num_of_tests_planned = $num_of_tests_run; $output.say: $indents ~ "1..$num_of_tests_planned"; } if ($num_of_tests_planned or $num_of_tests_run) && ($num_of_tests_planned != $num_of_tests_run) { ##Wrong quantity of tests diag("Looks like you planned $num_of_tests_planned test{ $num_of_tests_planned == 1 ?? '' !! 's'}, but ran $num_of_tests_run"); } if ($num_of_tests_failed) { diag("Looks like you failed $num_of_tests_failed test{ $num_of_tests_failed == 1 ?? '' !! 's'} of $num_of_tests_run"); } } sub _init_vars { $num_of_tests_run = 0; $num_of_tests_failed = 0; $todo_upto_test_num = 0; $todo_reason = ''; $num_of_tests_planned = Any; $no_plan = 1; $die_on_fail = Any; $time_before = NaN; $time_after = NaN; $done_testing_has_been_run = 0; } sub _push_vars { @vars.push: item [ $num_of_tests_run, $num_of_tests_failed, $todo_upto_test_num, $todo_reason, $num_of_tests_planned, $no_plan, $die_on_fail, $time_before, $time_after, $done_testing_has_been_run, ]; } sub _pop_vars { ( $num_of_tests_run, $num_of_tests_failed, $todo_upto_test_num, $todo_reason, $num_of_tests_planned, $no_plan, $die_on_fail, $time_before, $time_after, $done_testing_has_been_run, ) = @(@vars.pop); } END { ## In planned mode, people don't necessarily expect to have to call done ## So call it for them if they didn't if !$done_testing_has_been_run && !$no_plan { done-testing; } for $output, $failure_output, $todo_output -> $handle { next if $handle === ($*ERR|$*OUT); $handle.?close; } if $num_of_tests_failed and $num_of_tests_failed > 0 { exit($num_of_tests_failed min 254); } elsif !$no_plan && ($num_of_tests_planned or $num_of_tests_run) && $num_of_tests_planned != $num_of_tests_run { exit(255); } } =begin pod =head1 NAME Test - Rakudo Testing Library =head1 SYNOPSIS use Test; =head1 DESCRIPTION =head1 FUNCTIONS =head2 throws-like($code, Mu $expected_type, *%matchers) If C<$code> is C, calls it, otherwise Cs it, and expects it thrown an exception. If an exception is thrown, it is compared to C<$expected_type>. Then for each key in C<%matchers>, a method of that name is called on the resulting exception, and its return value smart-matched against the value. Each step is counted as a separate test; if one of the first two fails, the rest of the tests are skipped. =end pod # vim: expandtab shiftwidth=4 ft=perl6 rakudo-2015.11/lib/lib.pm6000644 000765 000024 00000000161 12603020567 017060 0ustar00williamcoledastaff000000 000000 module lib { }; my sub EXPORT(*@a) { @*INC.prepend: PARSE-INCLUDE-SPECS(@a.join(',')); return ().hash; } rakudo-2015.11/lib/newline.pm6000644 000765 000024 00000000253 12616676353 017773 0ustar00williamcoledastaff000000 000000 package EXPORT::crlf { BEGIN OUR::<$?NL> := "\x0D\x0A" } package EXPORT::cr { BEGIN OUR::<$?NL> := "\x0D" } package EXPORT::lf { BEGIN OUR::<$?NL> := "\x0A" } rakudo-2015.11/src/Perl6/Actions.nqp000644 000765 000024 00001260260 12623467502 021036 0ustar00williamcoledastaff000000 000000 use NQPP6QRegex; use NQPP5QRegex; use Perl6::Pod; use Perl6::Ops; use QRegex; use QAST; sub block_closure($code) { my $closure := QAST::Op.new( :op('callmethod'), :name('clone'), $code ); $closure := QAST::Op.new( :op('p6capturelex'), $closure); $closure.annotate('past_block', $code.ann('past_block')); $closure.annotate('code_object', $code.ann('code_object')); $closure } register_op_desugar('p6callmethodhow', -> $qast { $qast := $qast.shallow_clone(); my $inv := $qast.shift; my $tmp := QAST::Node.unique('how_invocant'); $qast.op('callmethod'); $qast.unshift(QAST::Var.new( :name($tmp), :scope('local') )); $qast.unshift(QAST::Op.new( :op('how'), QAST::Var.new( :name($tmp), :scope('local') ) )); QAST::Stmts.new( QAST::Op.new( :op('bind'), QAST::Var.new( :name($tmp), :scope('local'), :decl('var') ), $inv ), QAST::Op.new( :op('hllize'), $qast ) ) }); register_op_desugar('p6fatalize', -> $qast { my $tmp := QAST::Node.unique('fatalizee'); QAST::Stmts.new( :resultchild(0), QAST::Op.new( :op('bind'), QAST::Var.new( :name($tmp), :scope('local'), :decl('var') ), $qast[0] ), QAST::Op.new( :op('if'), QAST::Op.new( :op('istype'), QAST::Var.new( :name($tmp), :scope('local') ), $qast[1], ), QAST::Op.new( :op('callmethod'), :name('sink'), QAST::Var.new( :name($tmp), :scope('local') ) ) )) }); register_op_desugar('p6for', -> $qast { my $cond := $qast[0]; my $block := $qast[1]; my $label := $qast[2]; my $for-list-name := QAST::Node.unique('for-list'); my $iscont := QAST::Op.new(:op('iscont'), QAST::Var.new( :name($for-list-name), :scope('local') )); $iscont.named('item'); my $call := QAST::Op.new( :op, :name, :node($qast), QAST::Var.new( :name($for-list-name), :scope('local') ), $block, $iscont, ); if $label { $call.push($label); } my $bind := QAST::Op.new( :op('bind'), QAST::Var.new( :name($for-list-name), :scope('local'), :decl('var') ), $cond, ); QAST::Stmts.new( $bind, QAST::Op.new( :op, :name($qast.ann('context')), $call ) ); }); role STDActions { method quibble($/) { make $.ast; } method trim_heredoc($doc, $stop, $origast) { $origast.pop(); $origast.pop(); my str $ws := $stop.MATCH.Str; my int $actualchars := nqp::chars($ws); my int $indent := -$actualchars; my int $tabstop := $*W.find_symbol(['$?TABSTOP']); my int $checkidx := 0; while $checkidx < $actualchars { if nqp::eqat($ws, "\t", $checkidx) { $indent := $indent - ($tabstop - 1); } $checkidx := $checkidx + 1; } my $docast := $doc.MATCH.ast; if $docast.has_compile_time_value { my $dedented := nqp::unbox_s($docast.compile_time_value.indent($indent)); $origast.push($*W.add_string_constant($dedented)); } else { # we need to remove spaces from the beginnings of only textual lines, # so we have to track after each concatenation if the spaces at the # beginning of our chunk belong to a fresh line or come after an # interpolation or something my $in-fresh-line := 1; sub descend($node) { if nqp::istype($node, QAST::Want) { if +@($node) == 3 && $node[1] eq "Ss" { my $strval := $node[0].compile_time_value; if !$in-fresh-line { if $strval ~~ /\n/ { my $strbox := nqp::box_s(nqp::x(" ", -$indent) ~ nqp::unbox_s($strval), $*W.find_symbol(["Str"])); $strval := nqp::unbox_s($strbox.indent($indent)); $in-fresh-line := 1; return $*W.add_string_constant($strval); } } else { $strval := nqp::unbox_s($strval.indent($indent)); return $*W.add_string_constant($strval); } } } elsif nqp::istype($node, QAST::Op) && $node.op eq 'call' && $node.name eq '&infix:<~>' { my @results; # since we have the $in-fresh-line state, we need to traverse # and replace the child nodes in order for @($node) { nqp::push(@results, descend($node.shift)) } for @results { nqp::push($node, $_) } return $node; } $in-fresh-line := 0; return $node } $origast.push(descend($docast)) } $origast; } } class Perl6::Actions is HLL::Actions does STDActions { our @MAX_PERL_VERSION; # Could add to this based on signatures. our %commatrap := nqp::hash( '&categorize', 1, '&classify', 1, '&first', 1, '&first-index', 1, '&grep', 1, '&grep-index', 1, '&last-index', 1, '&map', 1, '&reduce', 1, '&sort', 1, ); INIT { # If, e.g., we support Perl up to v6.1.2, set # @MAX_PERL_VERSION to [6, 1, 2]. @MAX_PERL_VERSION[0] := 6; } sub sink($past) { QAST::Want.new( $past, 'v', QAST::Op.new( :op('p6sink'), $past ) ) } my %sinkable := nqp::hash( 'call', 1, 'callmethod', 1, 'if', 1, 'unless', 1, 'handle', 1, 'hllize', 1, ); sub autosink($past) { nqp::istype($past, QAST::Op) && %sinkable{$past.op} && !$past.ann('nosink') ?? sink($past) !! $past; } method ints_to_string($ints) { if nqp::islist($ints) { my $result := ''; for $ints { $result := $result ~ nqp::chr(nqp::unbox_i($_.ast)); } $result; } else { nqp::chr(nqp::unbox_i($ints.ast)); } } sub string_to_bigint($src, $base) { my $res := nqp::radix_I($base, ~$src, 0, 2, $*W.find_symbol(['Int'])); $src.CURSOR.panic("'$src' is not a valid number") unless nqp::iseq_i(nqp::unbox_i(nqp::atpos($res, 2)), nqp::chars($src)); nqp::atpos($res, 0); } sub xblock_immediate_with($xblock) { $xblock[1] := pblock_immediate_with($xblock[1]); $xblock; } sub xblock_immediate($xblock) { $xblock[1] := pblock_immediate($xblock[1]); $xblock; } sub pblock_immediate_with($pblock) { my $pb := block_immediate($pblock.ann('uninstall_if_immediately_used').shift); $pb.arity(1); # gotta force this, or Block node gets optimized away $pb; } sub pblock_immediate($pblock) { block_immediate($pblock.ann('uninstall_if_immediately_used').shift); } our sub block_immediate($block) { $block.blocktype('immediate'); $block; } method deflongname($/) { if $ { my $name := ~$; for $ { my $key := $_ || ''; if $_ -> $cf { if $cf -> $op_name { $name := $name ~ $*W.canonicalize_pair($key, $*W.colonpair_nibble_to_str( $/, $op_name // $op_name // $op_name)); } else { $name := $name ~ ':' ~ $key; } } else { $name := $name ~ ':' ~ $key; } } make $name; } else { make $*W.dissect_deflongname($/).name( :dba("$*IN_DECL declaration"), :decl, ); } } method deftermnow($/) { # 'my \foo' style declaration if $*SCOPE ne 'my' { $*W.throw($/, 'X::Comp::NYI', feature => "$*SCOPE scoped term definitions (only 'my' is supported at the moment)"); } my $name := $.ast; my $cur_lexpad := $*W.cur_lexpad; if $cur_lexpad.symbol($name) { $*W.throw($/, ['X', 'Redeclaration'], symbol => $name); } if $*OFTYPE { my $type := $*OFTYPE.ast; $cur_lexpad[0].push(QAST::Var.new( :$name, :scope('lexical'), :decl('var'), :returns($type) )); $cur_lexpad.symbol($name, :$type, :scope); } else { $cur_lexpad[0].push(QAST::Var.new(:$name, :scope('lexical'), :decl('var'))); $cur_lexpad.symbol($name, :scope('lexical')); } make $.ast; } method defterm($/) { my $name := ~$; if $ { for $ { my $key := $_ || ''; if $_ -> $cf { if $cf -> $op_name { $name := $name ~ $*W.canonicalize_pair($key, $*W.colonpair_nibble_to_str($/, $op_name)); } else { $name := $name ~ ':' ~ $key; } } else { $name := $name ~ ':' ~ $key; } } } make $name; } # Turn $code into "for lines() { $code }" sub wrap_option_n_code($/, $code) { $code := make_topic_block_ref($/, $code, copy => 1); my $past := QAST::Op.new(:op, :name, QAST::Op.new(:op, :name<&lines>), QAST::Op.new(:op, $code) ); $past := QAST::Want.new( QAST::Op.new( :op, :name, $past ), 'v', QAST::Op.new( :op, :name, $past ) ); } # Turn $code into "for lines() { $code; say $_ }" # &wrap_option_n_code already does the C loop, so we just add the # C call here sub wrap_option_p_code($/, $code) { wrap_option_n_code($/, QAST::Stmts.new( $code, QAST::Op.new(:name<&say>, :op, QAST::Var.new(:name<$_>, :scope) ) ) ) } method comp_unit($/) { # Finish up code object for the mainline. if $*DECLARAND { $*W.attach_signature($*DECLARAND, $*W.create_signature( nqp::hash('parameter_objects', []))); $*W.finish_code_object($*DECLARAND, $*UNIT); $*W.add_phasers_handling_code($*DECLARAND, $*UNIT); } # Checks. $*W.assert_stubs_defined($/); $*W.sort_protos(); # Get the block for the unit mainline code. my $unit := $*UNIT; my $mainline := QAST::Stmts.new( $*POD_PAST, statementlist_with_handlers($/) ); unless $*NEED_RESULT { # Evaluate last statement in sink context, by pushing another # statement after it, unless we need the result. $mainline.push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) )); } fatalize($mainline) if %*PRAGMAS; if %*COMPILING<%?OPTIONS>

{ # also covers the -np case, like Perl 5 $mainline[1] := QAST::Stmt.new(wrap_option_p_code($/, $mainline[1])); } elsif %*COMPILING<%?OPTIONS> { $mainline[1] := QAST::Stmt.new(wrap_option_n_code($/, $mainline[1])); } # We'll install our view of GLOBAL as the main one; any other # compilation unit that is using this one will then replace it # with its view later (or be in a position to restore it). my $global_install := QAST::Op.new( :op('bindcurhllsym'), QAST::SVal.new( :value('GLOBAL') ), QAST::WVal.new( :value($*GLOBALish) ) ); $*W.add_fixup_task(:deserialize_ast($global_install), :fixup_ast($global_install)); # Get the block for the entire compilation unit. my $outer := $*UNIT_OUTER; $outer.node($/); $*UNIT_OUTER.unshift(QAST::Var.new( :name('__args__'), :scope('local'), :decl('param'), :slurpy(1) )); $unit.name(''); $outer.name(''); # Load the needed libraries. $*W.add_libs($unit); # If the unit defines &MAIN, and this is in the mainline, # add a &MAIN_HELPER. if !$*W.is_precompilation_mode && +(@*MODULES // []) == 0 && $unit.symbol('&MAIN') { $mainline := QAST::Op.new( :op('call'), :name('&MAIN_HELPER'), $mainline, ); } # If our caller wants to know the mainline ctx, provide it here. # (CTXSAVE is inherited from HLL::Actions.) Don't do this when # there was an explicit {YOU_ARE_HERE}. unless $*HAS_YOU_ARE_HERE { $unit.push( self.CTXSAVE() ); } # Add the mainline code to the unit. $unit.push($mainline); # Executing the compilation unit causes the mainline to be executed. $outer.push(QAST::Op.new( :op, $unit )); # Do not want closure semantics on this outermost scope. $unit.blocktype('declaration_static'); # Wrap everything in a QAST::CompUnit. my $compunit := QAST::CompUnit.new( :hll('perl6'), # Serialization related bits. :sc($*W.sc()), :code_ref_blocks($*W.code_ref_blocks()), :compilation_mode($*W.is_precompilation_mode()), :pre_deserialize($*W.load_dependency_tasks()), :post_deserialize($*W.fixup_tasks()), :repo_conflict_resolver(QAST::Op.new( :op('callmethod'), :name('resolve_repossession_conflicts'), QAST::WVal.new( :value($*W.find_symbol(['CompUnitRepo'])) ) )), # If this unit is loaded as a module, we want it to automatically # execute the mainline code above after all other initializations # have occurred. :load(QAST::Op.new( :op('call'), QAST::BVal.new( :value($outer) ), )), # Finally, the outer block, which in turn contains all of the # other program elements. $outer ); # Pass some extra bits along to the optimizer. $compunit.annotate('UNIT', $unit); $compunit.annotate('GLOBALish', $*GLOBALish); $compunit.annotate('W', $*W); my @violations := @*NQP_VIOLATIONS; if @violations && !+nqp::ifnull(nqp::atkey(nqp::getenvhash,'RAKUDO_NO_DEPRECATIONS'),0) { my $file := nqp::getlexdyn('$?FILES'); my $bar := nqp::gethostname() eq 'ns1' ?? "" !! '=============================================================================== '; my $text := $bar ~ "The use of nqp::operations has been deprecated for non-CORE code. Please change your code to not use these non-portable functions. If you really want to keep using nqp::operations in your Perl6 code, you must add a: use nqp; to the outer scope of any code that uses nqp::operations. Compilation unit '$file' contained the following violations: "; my $line := -1; my $lines := nqp::elems(@violations); while ++$line < $lines { my @ops := @violations[$line]; next unless nqp::isconcrete(@ops); my $oplist := nqp::join(' nqp::',@ops); $text := $text ~ " Line $line:\n" ~ " nqp::$oplist\n"; } nqp::printfh(nqp::getstderr(),$text ~ $bar); } make $compunit; } method install_doc_phaser($/) { # Add a default DOC INIT phaser my $doc := %*COMPILING<%?OPTIONS>; if $doc { my $block := $*W.push_lexpad($/); my $renderer := "Pod::To::$doc"; my $module := $*W.load_module($/, $renderer, {}, $*GLOBALish); my $pod2text := QAST::Op.new( :op, :name, :node($/), self.make_indirect_lookup([$renderer]), QAST::Var.new(:name<$=pod>, :scope('lexical'), :node($/)) ); $block.push( QAST::Op.new( :op('if'), $pod2text, QAST::Op.new( :op, :node($/), :name('&say'), $pod2text, ), ) ); # TODO: We should print out $?USAGE too, # once it's known at compile time $block.push( QAST::Op.new( :op, :node($/), :name('&exit'), ) ); $*W.pop_lexpad(); $*W.add_phaser( $/, 'INIT', $*W.create_simple_code_object($block, 'Block'), $block ); } } method pod_content_toplevel($/) { my $child := $.ast; # make sure we don't push the same thing twice if $child { my $id := $/.from ~ "," ~ ~$/.to; if !$*POD_BLOCKS_SEEN{$id} { $*POD_BLOCKS.push($child); $*POD_BLOCKS_SEEN{$id} := 1; } } make $child; } method pod_content:sym($/) { make $.ast; } method pod_configuration($/) { make Perl6::Pod::make_config($/); } method pod_block:sym($/) { make Perl6::Pod::any_block($/); } method pod_block:sym($/) { make Perl6::Pod::raw_block($/); } method pod_block:sym($/) { make Perl6::Pod::table($/); } method pod_block:sym($/) { my $config := $.ast; my @contents := $.ast; my $twine := Perl6::Pod::serialize_array(@contents).compile_time_value; make Perl6::Pod::serialize_object( 'Pod::Block::Code', :contents($twine), :config($config), ).compile_time_value } method delimited_code_content($/) { my @t := []; for $/[0] { if $_ { nqp::splice(@t, Perl6::Pod::merge_twines($_), +@t, 0); nqp::push(@t, $*W.add_constant( 'Str', 'str', ~$_ ).compile_time_value); } else { @t.push($*W.add_constant('Str', 'str', "\n").compile_time_value); } } make @t; } method pod_block:sym($/) { make Perl6::Pod::any_block($/); } method pod_block:sym($/) { make Perl6::Pod::raw_block($/); } method pod_block:sym($/) { make Perl6::Pod::table($/); } method pod_block:sym($/) { my $config := $.ast; my @t := []; for $ { nqp::splice(@t, $_.ast, +@t, 0); } my $twine := Perl6::Pod::serialize_array(@t).compile_time_value; make Perl6::Pod::serialize_object( 'Pod::Block::Code', :contents($twine), :config($config), ).compile_time_value } method pod_block:sym($/) { make Perl6::Pod::any_block($/); } method pod_block:sym($/) { make Perl6::Pod::raw_block($/); } method pod_block:sym($/) { make Perl6::Pod::table($/); } method pod_block:sym($/) { my @t := []; for $ { nqp::splice(@t, $_.ast, +@t, 0); } my $twine := Perl6::Pod::serialize_array(@t).compile_time_value; make Perl6::Pod::serialize_object( 'Pod::Block::Code', :contents($twine) ).compile_time_value } method pod_line ($/) { my @t := Perl6::Pod::merge_twines($); @t.push($*W.add_constant( 'Str', 'str', ~$ ).compile_time_value); make @t; } method pod_block:sym($/) { $*W.install_lexical_symbol( $*UNIT,'$=finish', nqp::hllizefor(~$, 'perl6')); } method pod_content:sym($/) { make Perl6::Pod::config($/); } method pod_content:sym($/) { my @ret := []; for $ { @ret.push($_.ast); } my $past := Perl6::Pod::serialize_array(@ret); make $past.compile_time_value; } method pod_textcontent:sym($/) { my @t := Perl6::Pod::merge_twines($); my $twine := Perl6::Pod::serialize_array(@t).compile_time_value; make Perl6::Pod::serialize_object( 'Pod::Block::Para', :contents($twine) ).compile_time_value } method pod_textcontent:sym($/) { my $s := $.Str; my $t := subst($.Str, /\n$s/, "\n", :global); $t := subst($t, /\n$/, ''); # chomp! my $past := Perl6::Pod::serialize_object( 'Pod::Block::Code', :contents(Perl6::Pod::serialize_aos([$t]).compile_time_value), ); make $past.compile_time_value; } method pod_formatting_code($/) { if $ eq 'V' { make ~$; } elsif $ eq 'E' { my @contents := []; my @meta := []; for $/[0] { if $_ { @contents.push(~$_); @meta.push($*W.add_string_constant(~$_).compile_time_value); #my $s := Perl6::Pod::str_from_entity(~$_); #$s ?? @contents.push($s) && @meta.push(~$_) # !! $/.CURSOR.worry("\"$_\" is not a valid HTML5 entity."); } else { my $n := $_ ?? $_.made !! nqp::codepointfromname(~$_); if $n >= 0 { @contents.push(nqp::chr($n)); @meta.push($n); } else { $/.CURSOR.worry("\"$_\" is not a valid Unicode character name or code point."); } } } @contents := Perl6::Pod::serialize_aos(@contents).compile_time_value; @meta := Perl6::Pod::serialize_array(@meta).compile_time_value; make Perl6::Pod::serialize_object( 'Pod::FormattingCode', :type($*W.add_string_constant(~$).compile_time_value), :@contents, :@meta, ).compile_time_value; } else { my @contents := []; for $ { @contents.push($_.ast) } my @meta := []; if $ eq 'X' { for $/[0] { my @tmp := []; for $_ { @tmp.push(~$_); } @meta.push(@tmp); } @meta := Perl6::Pod::serialize_aoaos(@meta).compile_time_value; } else { for $ { @meta.push(~$_) } @meta := Perl6::Pod::serialize_aos(@meta).compile_time_value; } my @t := Perl6::Pod::build_pod_string(@contents); my $past := Perl6::Pod::serialize_object( 'Pod::FormattingCode', :type( $*W.add_string_constant(~$).compile_time_value ), :contents( Perl6::Pod::serialize_array(@t).compile_time_value ), :meta(@meta), ); make $past.compile_time_value; } } method pod_string($/) { my @contents := []; for $ { @contents.push($_.ast) } make Perl6::Pod::build_pod_string(@contents); } method pod_balanced_braces($/) { if $ { my @contents := []; my @stringparts := []; @stringparts.push(~$); if $ { for $ { if nqp::isstr($_.ast) { @stringparts.push($_.ast); } else { @contents.push(nqp::join("", @stringparts)); @stringparts := nqp::list(); @contents.push($_.ast); } } } @stringparts.push(~$); @contents.push(nqp::join("", @stringparts)); if +@contents == 1 { make @contents[0]; } else { make Perl6::Pod::build_pod_string(@contents); } } else { make ~$ } } method pod_string_character($/) { if $ { make $.ast } elsif $ { make $.ast } else { make ~$; } } method table_row($/) { make ~$/ } method table_row_or_blank($/) { make ~$/ } method unitstart($/) { # Use SET_BLOCK_OUTER_CTX (inherited from HLL::Actions) # to set dynamic outer lexical context and namespace details # for the compilation unit. self.SET_BLOCK_OUTER_CTX($*UNIT_OUTER); } method statementlist($/) { my $past := QAST::Stmts.new( :node($/) ); if $ { for $ { my $ast := $_.ast; if $ast { if $ast.ann('statement_level') && $*statement_level { $ast.ann('statement_level')(); } if $ast.ann('sink_ast') { $ast := QAST::Want.new($ast, 'v', $ast.ann('sink_ast')); } elsif $ast.ann('bare_block') { $ast := autosink($ast.ann('bare_block')); } else { $ast := QAST::Stmt.new(autosink($ast), :returns($ast.returns)); } $ast.node($_); $past.push( $ast ); } } } if +$past.list < 1 { $past.push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) )); } else { $past.returns($past[+@($past) - 1].returns); } make $past; } # Produces a LoL from a semicolon list method semilist($/) { if $ { my $past := QAST::Stmts.new( :node($/) ); if $ > 1 { my $l := QAST::Op.new( :name('&infix:<,>'), :op('call') ); for $ { $l.push($_.ast); } $past.push($l); $past.annotate('multislice', 1); } else { $past.push($[0].ast); } make $past; } else { make QAST::Op.new( :op('call'), :name('&infix:<,>') ); } } method sequence($/) { my $past := QAST::Stmts.new( :node($/) ); if $ { for $ { $past.push($_.ast) if $_.ast; } } unless +@($past) { $past.push( QAST::Op.new( :op('call'), :name('&infix:<,>') ) ); } make $past; } method statement($/) { my $past; if $ { my $mc := $; my $ml := $; $past := $.ast; if $mc { if ~$mc eq 'with' { make tailthunk_op('&infix:',[$mc,$]); return; } elsif ~$mc eq 'without' { make tailthunk_op('&infix:',[$mc,$]); return; } my $mc_ast := $mc.ast; if $past.ann('bare_block') { my $cond_block := $past.ann('past_block'); remove_block($*W.cur_lexpad(), $cond_block); $cond_block.blocktype('immediate'); $past := $cond_block; } $mc_ast.push($past); $mc_ast.push(QAST::WVal.new( :value($*W.find_symbol(['Empty'])) )); $past := $mc_ast; } if $ml { my $cond := $ml.ast; if ~$ml eq 'given' { unless $past.ann('bare_block') { $past := make_topic_block_ref($/, $past, migrate_stmt_id => $*STATEMENT_ID); } $past := QAST::Op.new( :op('call'), block_closure($past), $cond ); } elsif ~$ml eq 'for' { unless $past.ann('past_block') { $past := make_topic_block_ref($/, $past, migrate_stmt_id => $*STATEMENT_ID); } $past := QAST::Want.new( QAST::Op.new( :op, :node($/), $cond, block_closure($past), ), 'v', QAST::Op.new( :op, :node($/), $cond, block_closure($past), ), ); $past[0].annotate('context', 'eager'); $past[2].annotate('context', 'sink'); my $sinkee := $past[0]; $past.annotate('statement_level', -> { $sinkee.annotate('context', 'sink') }); } else { $past := QAST::Op.new($cond, $past, :op(~$ml), :node($/) ); } } } elsif $ { $past := $.ast; } elsif $ { $past := $.ast; } else { $past := 0; } if $past { my $id := $*STATEMENT_ID; $past.annotate('statement_id', $id); # only trace when running in source if %*PRAGMAS && !$*W.is_precompilation_mode { my $code := ~$/; # don't bother putting ops for activating it if $code eq 'use trace' { $past := 0; } # need to generate code else { my $line := $*W.current_line($/); my $file := $*W.current_file; $code := subst($code, /\s+$/, ''); # chomp! $past := QAST::Stmts.new(:node($/), QAST::Op.new( :op, QAST::Op.new(:op), QAST::SVal.new(:value("$id ($file:$line)\n$code")) ), $past ); } } } make $past; } method xblock($/) { make QAST::Op.new( $.ast, $.ast, :op('if'), :node($/) ); } method pblock($/) { if $ { make $.ast; } else { # Locate or build a set of parameters. my %sig_info; my @params; my $block := $.ast; if $block.ann('placeholder_sig') && $ { $*W.throw($/, ['X', 'Signature', 'Placeholder'], precursor => '1', placeholder => $block.ann('placeholder_sig')[0], ); } elsif $block.ann('placeholder_sig') { @params := $block.ann('placeholder_sig'); %sig_info := @params; if $*IMPLICIT { $block[0].push(QAST::Op.new( :op('bind'), QAST::Var.new( :name('$_'), :scope('lexical') ), QAST::Op.new( :op('getlexouter'), QAST::SVal.new( :value('$_') ) ) )); } } elsif $ { %sig_info := %*SIG_INFO; @params := %sig_info; if $*IMPLICIT { my int $declares_topic := 0; for @params { if $_ eq '$_' { $declares_topic := 1; } } unless $declares_topic { $block[0].push(QAST::Op.new( :op('bind'), QAST::Var.new( :name('$_'), :scope('lexical') ), QAST::Op.new( :op('getlexouter'), QAST::SVal.new( :value('$_') ) ) )); } } } else { if $*IMPLICIT { @params.push(hash( :variable_name('$_'), :optional(1), :nominal_type($*W.find_symbol(['Mu'])), :default_from_outer(1), :is_raw(1), )); } elsif !$block.symbol('$_') { $block[0].push(QAST::Op.new( :op('bind'), QAST::Var.new( :name('$_'), :scope('lexical'), :decl('var') ), QAST::Op.new( :op('getlexouter'), QAST::SVal.new( :value('$_') ) ) )); $block.symbol('$_', :scope('lexical'), :type($*W.find_symbol(['Mu']))); } %sig_info := @params; } # Create signature object if we didn't already, and set up binding. my $signature := $*SIG_OBJ // $*W.create_signature_and_params( $, %sig_info, $block, 'Mu'); add_signature_binding_code($block, $signature, @params); # We'll install PAST in current block so it gets capture_lex'd. # Then evaluate to a reference to the block (non-closure - higher # up stuff does that if it wants to). ($*W.cur_lexpad())[0].push(my $uninst := QAST::Stmts.new($block)); Perl6::Pod::document($/, $*DECLARAND, $*POD_BLOCK, :leading); $*W.attach_signature($*DECLARAND, $signature); $*W.finish_code_object($*DECLARAND, $block); $*W.add_phasers_handling_code($*DECLARAND, $block); my $ref := reference_to_code_object($*DECLARAND, $block); $ref.annotate('uninstall_if_immediately_used', $uninst); make $ref; } } method block($/) { my $block := $.ast; if $block.ann('placeholder_sig') { my $name := $block.ann('placeholder_sig')[0]; unless $name eq '%_' || $name eq '@_' { $name := nqp::concat(nqp::substr($name, 0, 1), nqp::concat('^', nqp::substr($name, 1))); } $*W.throw( $/, ['X', 'Placeholder', 'Block'], placeholder => $name, ); } ($*W.cur_lexpad())[0].push(my $uninst := QAST::Stmts.new($block)); $*W.attach_signature($*DECLARAND, $*W.create_signature(nqp::hash('parameter_objects', []))); $*W.finish_code_object($*DECLARAND, $block); $*W.add_phasers_handling_code($*DECLARAND, $block); my $ref := reference_to_code_object($*DECLARAND, $block); $ref.annotate('uninstall_if_immediately_used', $uninst); make $ref; } method blockoid($/) { if $ { my $past := statementlist_with_handlers($/); my $BLOCK := $*CURPAD; $BLOCK.blocktype('declaration_static'); $BLOCK.push($past); $BLOCK.node($/); $BLOCK.annotate('handlers', %*HANDLERS) if %*HANDLERS; fatalize($past) if %*PRAGMAS; make $BLOCK; } else { if $*HAS_YOU_ARE_HERE { $/.CURSOR.panic('{YOU_ARE_HERE} may only appear once in a setting'); } $*HAS_YOU_ARE_HERE := 1; make $.ast; } } sub statementlist_with_handlers($/) { my $past := $.ast; my $ret := %*SIG_INFO; $past.push(QAST::WVal.new(:value($ret))) if nqp::isconcrete($ret) || $ret.HOW.name($ret) eq 'Nil'; if %*HANDLERS { $past := QAST::Op.new( :op('handle'), $past ); for %*HANDLERS { $past.push($_.key); $past.push($_.value); } } $past } # Under "use fatal", re-write all calls to fatalize their return value # unless we can see they are in a boolean context. my %boolify_first_child_ops := nqp::hash( 'if', 1, 'unless', 1, 'defor', 1, 'p6bool', 1, 'while', 1, 'until', 1, 'repeat_while', 1, 'repeat_until', 1, ); my %boolify_first_child_calls := nqp::hash( '&prefix:', 1, '&prefix:', 1, '&prefix:', 1, '&prefix:', 1, '&defined', 1 ); sub fatalize($ast, $bool-context = 0) { if nqp::istype($ast, QAST::Op) { my str $op := $ast.op; if $op eq 'p6fatalize' { # We've been here before (tree with shared bits, presumably). } elsif nqp::existskey(%boolify_first_child_ops, $op) || $op eq 'call' && nqp::existskey(%boolify_first_child_calls, $ast.name) { my int $first := 1; for @($ast) { if $first { fatalize($_, 1); $first := 0; } else { fatalize($_); } } } elsif $op eq 'hllize' { fatalize($_, $bool-context) for @($ast); } else { fatalize($_) for @($ast); if !$bool-context && ($op eq 'call' || $op eq 'callmethod') { if $ast.name eq '&fail' { $ast.name('&die'); } else { my $new-node := QAST::Op.new( :node($ast.node), :$op, :name($ast.name), :returns($ast.returns) ); $new-node.push($ast.shift) while @($ast); $ast.op('p6fatalize'); $ast.push($new-node); $ast.push(QAST::WVal.new( :value($*W.find_symbol(['Failure'])) )); } } } } elsif nqp::istype($ast, QAST::Stmt) || nqp::istype($ast, QAST::Stmts) || nqp::istype($ast, QAST::Want) { fatalize($_) for @($ast); } } method you_are_here($/) { make self.CTXSAVE(); } method newpad($/) { my $new_block := $*W.cur_lexpad(); $new_block.annotate('IN_DECL', $*IN_DECL); } method finishpad($/) { # Generate the $_, $/, and $! lexicals for routines if they aren't # already declared. For blocks, $_ will come from the outer if it # isn't already declared. my $BLOCK := $*W.cur_lexpad(); my $type := $BLOCK.ann('IN_DECL'); if $type eq 'mainline' && %*COMPILING<%?OPTIONS> eq 'NULL' { # Don't do anything in the case where we are in the mainline of # the setting; we don't have any symbols (Scalar, etc.) yet. return 1; } my $is_routine := $type eq 'sub' || $type eq 'method' || $type eq 'submethod' || $type eq 'mainline'; if $is_routine { # Generate the lexical variable except if... # (1) the block already has one, or # (2) the variable is '$_' and $*IMPLICIT is set # (this case gets handled by getsig) unless $BLOCK.symbol('$_') || $*IMPLICIT { $*W.install_lexical_magical($BLOCK, '$_'); } for <$/ $! $¢> { unless $BLOCK.symbol($_) { $*W.install_lexical_magical($BLOCK, $_); } } } else { unless $BLOCK.symbol('$_') { $BLOCK[0].push(QAST::Var.new( :name('$_'), :scope('lexical'), :decl('var') )); unless $*IMPLICIT { $BLOCK[0].push(QAST::Op.new( :op('bind'), QAST::Var.new( :name('$_'), :scope('lexical') ), QAST::Op.new( :op('getlexouter'), QAST::SVal.new( :value('$_') ) ) )); } $BLOCK.symbol('$_', :scope('lexical'), :type($*W.find_symbol(['Mu']))); } } } ## Statement control method statement_control:sym($/) { my $count := +$ - 1; my $past; if ~$[$count] ~~ /with/ { $past := xblock_immediate_with( $[$count].ast ); $past.op('with'); $past.push( $ ?? pblock_immediate_with( $.ast ) !! QAST::WVal.new( :value($*W.find_symbol(['Empty'])) ) ); } else { $past := xblock_immediate( $[$count].ast ); $past.op('if'); $past.push( $ ?? pblock_immediate( $.ast ) !! QAST::WVal.new( :value($*W.find_symbol(['Empty'])) ) ); } # build if/then/elsif structure while $count > 0 { $count--; my $else := $past; if ~$[$count] ~~ /with/ { $past := xblock_immediate_with( $[$count].ast ); $past.op('with'); } else { $past := xblock_immediate( $[$count].ast ); $past.op('if'); } $past.push($else); } make $past; } method statement_control:sym($/) { my $past := $ eq 'without' ?? xblock_immediate_with( $.ast ) !! xblock_immediate( $.ast ); $past.push(QAST::WVal.new( :value($*W.find_symbol(['Empty'])) )); $past.op(~$); make $past; } method statement_control:sym($/) { my $past := xblock_immediate( $.ast ); $past.op(~$); make tweak_loop($past); } method statement_control:sym($/) { my $op := 'repeat_' ~ ~$; my $past; if $ { $past := xblock_immediate( $.ast ); $past.op($op); } else { $past := QAST::Op.new( $.ast, pblock_immediate( $.ast ), :op($op), :node($/) ); } make tweak_loop($past); } method statement_control:sym($/) { my $xblock := $.ast; my $past := QAST::Want.new( QAST::Op.new( :op, :node($/), $xblock[0], block_closure($xblock[1]), ), 'v', QAST::Op.new( :op, :node($/), $xblock[0], block_closure($xblock[1]), ), ); if $*LABEL { my $label := QAST::WVal.new( :value($*W.find_symbol([$*LABEL])), :named('label') ); $past[0].push($label); $past[2].push($label); } $past[0].annotate('context', 'eager'); $past[2].annotate('context', 'sink'); my $sinkee := $past[0]; $past.annotate('statement_level', -> { $sinkee.annotate('context', 'sink') }); make $past; } method statement_control:sym($/) { my $xblock := $.ast; make QAST::Op.new( :op, :name<&WHENEVER>, :node($/), $xblock[0], block_closure($xblock[1]) ); } method statement_control:sym($/) { my $block := pblock_immediate($.ast); my $cond := $ ?? $.ast !! QAST::IVal.new( :value(1) ); my $loop := QAST::Op.new( $cond, :op('while'), :node($/) ); $loop.push($block); if $ { $loop.push(sink($.ast)); } $loop := tweak_loop($loop); if $ { $loop := QAST::Stmts.new( $.ast, $loop, :node($/) ); } make $loop; } sub tweak_loop($loop) { if $*LABEL { $loop.push(QAST::WVal.new( :value($*W.find_symbol([$*LABEL])), :named('label') )); } # Handle phasers. my $code := $loop[1].ann('code_object'); my $block_type := $*W.find_symbol(['Block']); my $phasers := nqp::getattr($code, $block_type, '$!phasers'); unless nqp::isnull($phasers) { if nqp::existskey($phasers, 'NEXT') { my $phascode := $*W.run_phasers_code($code, $loop[1], $block_type, 'NEXT'); if +@($loop) == 2 { $loop.push($phascode); } else { $loop[2] := QAST::Stmts.new($phascode, $loop[2]); } } if nqp::existskey($phasers, 'FIRST') { $loop := QAST::Stmts.new( QAST::Op.new( :op('p6setfirstflag'), QAST::WVal.new( :value($code) ) ), $loop); } if nqp::existskey($phasers, 'LAST') { $loop := QAST::Stmts.new( :resultchild(0), $loop, $*W.run_phasers_code($code, $loop[1], $block_type, 'LAST')); } } $loop } method statement_control:sym($/) { my $past := QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ); for $ { # XXX TODO: Version checks. } make $past; } method statement_control:sym($/) { my $past := QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ); make $past; } method statement_control:sym($/) { my $past := QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ); if $ { $past := $.ast; } elsif $ { # TODO: replace this by code that doesn't always die with # a useless error message # my $i := -1; # for $ { # ++$i; # if $_ ne '*' && $_ < @MAX_PERL_VERSION[$i] { # last; # } elsif $_ > @MAX_PERL_VERSION[$i] { # my $mpv := nqp::join('.', @MAX_PERL_VERSION); # $/.CURSOR.panic("Perl $ required--this is only v$mpv") # } # } } make $past; } method statement_control:sym($/) { my $past := QAST::Stmts.new(:node($/)); my $name_past := $ ?? $*W.dissect_longname($).name_past() !! $.ast; my $op := QAST::Op.new( :op('callmethod'), :name('load_module'), QAST::WVal.new( :value($*W.find_symbol(['CompUnitRepo'])) ), $name_past, QAST::Op.new( :op('hash') ), $*W.symbol_lookup(['GLOBAL'], $/), ); if $ { for $ -> $colonpair { $op.push( QAST::Op.new( :named(~$colonpair), :op, :name, $colonpair.ast ) ); } } else { $op.push( QAST::Op.new( :named, :op, :name, $.ast ) ); } $past.push($op); if $ { my $p6_argiter := $*W.compile_time_evaluate($/, $.ast).eager.iterator; my $IterationEnd := $*W.find_symbol(['IterationEnd']); my $lexpad := $*W.cur_lexpad(); my $*SCOPE := 'my'; my $import_past := QAST::Op.new(:node($/), :op, :name<&REQUIRE_IMPORT>, $name_past); while !((my $arg := $p6_argiter.pull-one) =:= $IterationEnd) { my $symbol := nqp::unbox_s($arg.Str()); $*W.throw($/, ['X', 'Redeclaration'], :$symbol) if $lexpad.symbol($symbol); declare_variable($/, $past, nqp::substr($symbol, 0, 1), '', nqp::substr($symbol, 1), []); $import_past.push($*W.add_string_constant($symbol)); } $past.push($import_past); } $past.push(QAST::WVal.new( :value($*W.find_symbol(['True'])) )); make $past; } method statement_control:sym($/) { my $past := $.ast; $past.push($past.shift); # swap [0] and [1] elements $past[0] := block_closure($past[0]); $past.op('call'); make $past; } method statement_control:sym($/) { # Get hold of the smartmatch expression and the block. my $xblock := $.ast; my $sm_exp := $xblock.shift; my $pblock := $xblock.shift; check_smartmatch($/,$sm_exp); # Handle the smart-match. my $match_past := QAST::Op.new( :op('callmethod'), :name('ACCEPTS'), $sm_exp, QAST::Var.new( :name('$_'), :scope('lexical') ) ); # Use the smartmatch result as the condition for running the block, # and ensure continue/succeed handlers are in place and that a # succeed happens after the block. $pblock := pblock_immediate($pblock); make QAST::Op.new( :op('if'), :node( $/ ), $match_past, when_handler_helper($pblock) ); } method statement_control:sym($/) { # We always execute this, so just need the block, however we also # want to make sure we succeed after running it. make when_handler_helper($.ast); } method term:sym($/) { my @inner_statements := $; my $wild_done; my $wild_more; my $wait; my $wait_time; my $past := QAST::Op.new( :op('call'), :name('&EARLIEST'), :node($/) ); if $ { if nqp::istype($.ast.returns, $*W.find_symbol(['Whatever'])) { $past.push( QAST::Op.new( :op('callmethod'), :name('new'), QAST::WVal.new( :value($*W.find_symbol(['List'])) ) )); } else { $past.push( QAST::Op.new(:name('&flat'), :op('call'), $.ast) ); } } elsif $ { $past.push( QAST::Op.new( :op('callmethod'), :name('new'), QAST::WVal.new( :value($*W.find_symbol(['List'])) ) )); } # TODO verify that the inner block only has more/done/later blocks in it for @inner_statements -> $/ { if $ -> $/ { if $ eq 'done' { if nqp::istype($.ast.returns, $*W.find_symbol(['Whatever'])) { # TODO error $wild_done := block_closure($.ast); $wild_done.named('wild_done'); } else { $past.push(QAST::IVal.new(:value(0))); # "DONE" $past.push($.ast); $past.push(block_closure($.ast)); } } elsif $ eq 'more' { if nqp::istype($.ast.returns, $*W.find_symbol(['Whatever'])) { $wild_more := block_closure($.ast); $wild_more.named('wild_more'); } else { $past.push(QAST::IVal.new(:value(1))); # "MORE" $past.push($.ast); $past.push(block_closure($.ast)); } } elsif $ eq 'wait' { # TODO error $wait_time:= $.ast; $wait_time.named('wait_time'); $wait := block_closure($.ast); $wait.named('wait'); } else { # TODO error } } else { # TODO error } } if $wild_done { $past.push( $wild_done ) } if $wild_more { $past.push( $wild_more ) } if $wait { $past.push( $wait ); $past.push( $wait_time ) } make $past; } method term:sym($/) { $*W.throw($/, ['X', 'NYI'], feature => 'combine blocks'); } method statement_control:sym($/) { $*W.throw($/, ['X', 'NYI'], feature => 'combine blocks (and "quit")'); } method statement_control:sym($/) { if nqp::existskey(%*HANDLERS, 'CATCH') { $*W.throw($/, ['X', 'Phaser', 'Multiple'], block => 'CATCH'); } my $block := $.ast; set_block_handler($/, $block, 'CATCH'); make QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ); } method statement_control:sym($/) { if nqp::existskey(%*HANDLERS, 'CONTROL') { $*W.throw($/, ['X', 'Phaser', 'Multiple'], block => 'CONTROL'); } my $block := $.ast; set_block_handler($/, $block, 'CONTROL'); make QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ); } method statement_control:sym($/) { my $block := $.ast; # Take exception as parameter and bind into $_. my $past := $block.ann('past_block'); $past[0].push(QAST::Op.new( :op('bind'), QAST::Var.new( :name('$_'), :scope('lexical') ), QAST::Var.new( :name('__param'), :scope('local'), :decl('param') ) )); # If the handler has a succeed handler, then make sure we sink # the exception it will produce. if $past.ann('handlers') && nqp::existskey($past.ann('handlers'), 'SUCCEED') { my $suc := $past.ann('handlers'); $suc[0] := QAST::Stmts.new( sink(QAST::Op.new( :op('getpayload'), QAST::Op.new( :op('exception') ) )), QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ) ); } # If we don't handle the exception by succeeding, we'll return it. if $past.ann('handlers') { $past[1][0].push(QAST::Var.new( :name('$_'), :scope('lexical') )); } else { $past[1].push(QAST::Var.new( :name('$_'), :scope('lexical') )); } # Add as a QUIT phaser, which evaluates to Nil. make $*W.add_phaser($/, 'QUIT', $block.ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'BEGIN', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'COMPOSE', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'CHECK', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'INIT', ($.ast).ann('code_object'), ($.ast).ann('past_block')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'ENTER', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'FIRST', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'END', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'LEAVE', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'KEEP', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'UNDO', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'NEXT', ($.ast).ann('code_object')); } method statement_prefix:sym($/) { make $*W.add_phaser($/, 'LAST', ($.ast).ann('code_object')); } method statement_prefix:sym

($/)   { make $*W.add_phaser($/, 'PRE', ($.ast).ann('code_object'), ($.ast).ann('past_block')); }
    method statement_prefix:sym($/)  { make $*W.add_phaser($/, 'POST', ($.ast).ann('code_object'), ($.ast).ann('past_block')); }

    method statement_prefix:sym($/)   {
        if %*COMPILING<%?OPTIONS> {
            make $*W.add_phaser($/, ~$, ($.ast).ann('code_object'), ($.ast).ann('past_block'));
        }
        else {
            make QAST::WVal.new( :value($*W.find_symbol(['Nil'])) );
        }
    }

    method statement_prefix:sym($/) {
        make QAST::Op.new( :op('call'), $.ast );
    }

    method statement_prefix:sym($/) {
        my $past := block_closure($.ast);
        $past.ann('past_block').push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
        make QAST::Op.new( :op('call'), :name('&GATHER'), $past );
    }

    method statement_prefix:sym($/) {
        my $past := block_closure($.ast);
        $past.ann('past_block').push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
        make QAST::Op.new( :op('call'), :name('&SUPPLY'), $past );
    }

    method statement_prefix:sym($/) {
        my $past := block_closure($.ast);
        $past.ann('past_block').push(QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
        make QAST::Op.new( :op('call'), :name('&REACT'), $past );
    }

    method statement_prefix:sym($/) {
        # create state variable to remember whether we ran the block
        my $pad := $*W.cur_lexpad();
        my $sym := $pad.unique('once_');
        my $mu := $*W.find_symbol(['Mu']);
        my $descriptor := $*W.create_container_descriptor($mu, 1, $sym);
        my %info;
        %info := %info := $*W.find_symbol(['Scalar']);
        %info := %info := %info := %info := $mu;
        $*W.install_lexical_container($pad, $sym, %info, $descriptor, :scope('state'));

        # generate code that runs the block only once
        make QAST::Op.new(
            :op('if'),
            QAST::Op.new( :op('p6stateinit') ),
            QAST::Op.new(
                :op('p6store'),
                QAST::Var.new( :name($sym), :scope('lexical') ),
                QAST::Op.new( :op('call'), $.ast )
            ),
            QAST::Var.new( :name($sym), :scope('lexical') )
        );
    }

    method statement_prefix:sym($/) {
        make QAST::Op.new(
            :op('callmethod'),
            :name('start'),
            :returns($*W.find_symbol(['Promise'])),
            QAST::WVal.new( :value($*W.find_symbol(['Promise'])) ),
            $.ast
        );
    }

    method statement_prefix:sym($/) {
        make QAST::Op.new(
            :op('callmethod'), :name('lazy'),
            QAST::Op.new( :op('call'), $.ast )
        );
    }

    method statement_prefix:sym($/) {
        make QAST::Op.new(
            :op('callmethod'), :name('eager'),
            QAST::Op.new( :op('call'), $.ast )
        );
    }

    method statement_prefix:sym($/) {
        make QAST::Op.new(
            :op('callmethod'), :name('hyper'),
            QAST::Op.new( :op('call'), $.ast )
        );
    }

    method statement_prefix:sym($/) {
        make QAST::Op.new(
            :op('callmethod'), :name('race'),
            QAST::Op.new( :op('call'), $.ast )
        );
    }

    method statement_prefix:sym($/) {
        make QAST::Stmts.new(
            QAST::Op.new(
                :op('callmethod'), :name('eager'),
                QAST::Op.new( :op('call'), $.ast )
            ),
            QAST::Var.new( :name('Nil'), :scope('lexical')),
            :node($/)
        );
    }

    method statement_prefix:sym($/) {
        my $block := $.ast;
        my $past;
        if $block.ann('past_block').ann('handlers') && $block.ann('past_block').ann('handlers') {
            # we already have a CATCH block, nothing to do here
            $past := QAST::Op.new( :op('call'), $block );
        } else {
            $block := QAST::Op.new(:op, $block);
            $past := QAST::Op.new(
                :op('handle'),

                # Success path puts Any into $! and evaluates to the block.
                QAST::Stmt.new(
                    :resultchild(0),
                    $block,
                    QAST::Op.new(
                        :op('p6store'),
                        QAST::Var.new( :name<$!>, :scope ),
                        QAST::Var.new( :name, :scope )
                    )
                ),

                # On failure, capture the exception object into $!.
                'CATCH', QAST::Stmts.new(
                    QAST::Op.new(
                        :op('p6store'),
                        QAST::Var.new(:name<$!>, :scope),
                        QAST::Op.new(
                            :name<&EXCEPTION>, :op,
                            QAST::Op.new( :op('exception') )
                        ),
                    ),
                    QAST::WVal.new(
                        :value( $*W.find_symbol(['Nil']) ),
                    ),
                )
            );
        }
        make $past;
    }

    method statement_prefix:sym($/) {
        make QAST::Op.new(
            :op('handle'),
            QAST::Op.new( :op('call'), $.ast ),
            'WARN',
            QAST::Op.new( :op('resume'), QAST::Op.new( :op('exception') ) )
        );
    }

    method blorst($/) {
        my $block;
        if $ {
            $block := $.ast;
        }
        else {
            my $stmt := $.ast;
            $block := make_thunk_ref($stmt, $/);
            migrate_blocks($*W.cur_lexpad, $block.ann('past_block'),
                -> $b { $b.ann('statement_id') == $stmt.ann('statement_id') });
        }
        make block_closure($block);
    }

    # Statement modifiers

    method modifier_expr($/) { make $.ast; }

    method statement_mod_cond:sym($/)     {
        make QAST::Op.new( :op, $.ast, :node($/) );
    }

    method statement_mod_cond:sym($/) {
        make QAST::Op.new( :op, $.ast, :node($/) );
    }

    method statement_mod_cond:sym($/) {
        my $pat := $.ast;
        check_smartmatch($/,$pat);
        make QAST::Op.new( :op,
            QAST::Op.new( :name('ACCEPTS'), :op('callmethod'),
                          $pat,
                          QAST::Var.new( :name('$_'), :scope('lexical') ) ),
            :node($/)
        );
    }

    method statement_mod_cond:sym($/)    { make $.ast; }
    method statement_mod_cond:sym($/) { make $.ast; }

    method statement_mod_loop:sym($/)  { make $.ast; }
    method statement_mod_loop:sym($/)  { make $.ast; }
    method statement_mod_loop:sym($/)    { make $.ast; }
    method statement_mod_loop:sym($/)  { make $.ast; }

    ## Terms

    method term:sym($/)           { make $.ast; }
    method term:sym($/)          { make $.ast; }
    method term:sym($/)           { make $.ast; }
    method term:sym($/) { make $.ast; }
    method term:sym($/)   { make $.ast; }
    method term:sym($/) { make $.ast; }
    method term:sym($/)   { make $.ast; }
    method term:sym($/)   { make $.ast; }
    method term:sym($/)    { make $.ast; }
    method term:sym($/)          { make $.ast; }
    method term:sym($/)   { make $.ast; }
    method term:sym($/)            { make $.ast; }
    method term:sym($/) {
        my $ast   := $.ast;
        my $block := $ast.ann('past_block');
        $block[0].push(QAST::Var.new( :name('$*DISPATCHER'), :scope('lexical'), :decl('var') ));
        $block[0].push(QAST::Op.new(
            :op('takedispatcher'),
            QAST::SVal.new( :value('$*DISPATCHER') )
        ));
        make block_closure($ast);
    }
    method term:sym($/) {
        make QAST::Unquote.new(:position(nqp::elems(@*UNQUOTE_ASTS)));
        @*UNQUOTE_ASTS.push($.ast);
    }

    method name($/) { }

    method fatarrow($/) {
        make make_pair($.Str, $.ast);
    }

    method coloncircumfix($/) {
        make $
            ?? $.ast
            !! QAST::WVal.new( :value($*W.find_symbol(['Nil'])) );
    }

    method colonpair($/) {
        if $*key {
            if $ {
                make make_pair($*key, $.ast);
            }
            elsif $ {
                make make_pair($*key, $*W.add_numeric_constant($/, 'Int', $*value));
            }
            elsif $*value ~~ NQPMatch {
                my $val_ast := $*value.ast;
                if $val_ast.isa(QAST::Stmts) && +@($val_ast) == 1 {
                    $val_ast := $val_ast[0];
                }
                make make_pair($*key, $val_ast);
            }
            else {
                make make_pair($*key, QAST::Op.new(
                    :op('p6bool'),
                    QAST::IVal.new( :value($*value) )
                ));
            }
        }
        elsif $ {
            make $.ast;
        }
        else {
            make $*value.ast;
        }
    }

    method colonpair_variable($/) {
        if $ {
            make QAST::Op.new(
                :op('call'),
                :name('&postcircumfix:<{ }>'),
                QAST::Var.new(:name('$/'), :scope('lexical')),
                $*W.add_string_constant(~$)
            );
        }
        else {
            make make_variable($/, [~$/]);
        }
    }

    sub make_pair($key_str, $value) {
        my $key := $*W.add_string_constant($key_str);
        QAST::Op.new(
            :op('callmethod'), :name('new'), :returns($*W.find_symbol(['Pair'])),
            QAST::Var.new( :name('Pair'), :scope('lexical') ),
            $key, $value
        )
    }

    method desigilname($/) {
        if $ {
            make QAST::Op.new( :op('callmethod'), $.ast );
        }
    }

    method variable($/) {
        my $past;
        if $ {
            $past := QAST::Op.new(
                :op('call'),
                :name('&postcircumfix:<[ ]>'),
                QAST::Var.new(:name('$/'), :scope('lexical')),
                $*W.add_constant('Int', 'int', +$),
            );
            if $ eq '@' || $ eq '%' {
                my $name := $ eq '@' ?? 'list' !! 'hash';
                $past := QAST::Op.new( :op('callmethod'), :name($name), $past );
            }
        }
        elsif $ {
            $past := $.ast;
            $past.unshift( QAST::Var.new( :name('$/'), :scope('lexical') ) );
            if $ eq '@' || $ eq '%' {
                my $name := $ eq '@' ?? 'list' !! 'hash';
                $past := QAST::Op.new( :op('callmethod'), :name($name), $past );
            }
        }
        elsif $ {
            $past := $.ast;
        }
        elsif $ {
            my $name := '&infix' ~ $*W.canonicalize_pair('', $.Str);
            $past := QAST::Op.new(
                :op('ifnull'),
                QAST::Var.new( :name($name), :scope('lexical') ),
                QAST::Op.new(
                    :op('die_s'),
                    QAST::SVal.new( :value("Could not find sub $name") )
                ));
        }
        elsif $ {
            $past := $.ast;
            $past.name(~$ eq '@' ?? 'cache' !!
                       ~$ eq '%' ?? 'hash' !!
                                           'item');
        }
        else {
            my $indirect;
            if $ && $ {
                my $longname := $*W.dissect_longname($);
                if $longname.contains_indirect_lookup() {
                    if $*IN_DECL {
                        $*W.throw($/, ['X', 'Syntax', 'Variable', 'IndirectDeclaration']);
                    }
                    $past := self.make_indirect_lookup($longname.components(), ~$);
                    $indirect := 1;
                }
                else {
                    $past := make_variable($/, $longname.attach_adverbs.variable_components(
                        ~$, $ ?? ~$ !! ''));
                }
            }
            else {
                my $name := ~$/;
                if !$*IN_DECL && nqp::chars($name) == 1 && $name eq ~$ {
                    my $*IN_DECL := 'variable';
                    my $*SCOPE := 'state';
                    my $*OFTYPE;  # should default to Mu/Mu/Any
                    $past := QAST::Var.new( :node($/) );
                    $past := declare_variable($/, $past, $name, '', '', []);
                    $past.annotate('nosink', 1);
                }
                else {
                    $past := make_variable($/, [$name]);
                }
            }
        }
        if $*IN_DECL eq 'variable' {
            $past.annotate('sink_ok', 1);
        }

        make $past;
    }

    method contextualizer($/) {
        my $past := $.ast;
        if $ eq '$' && ~$ eq '' { # for '$()'
            my $result_var := $past.unique('sm_result');
            $past := QAST::Stmt.new(
                # Evaluate RHS and call ACCEPTS on it, passing in $_. Bind the
                # return value to a result variable.
                QAST::Op.new( :op('bind'),
                    QAST::Var.new( :name($result_var), :scope('local'), :decl('var') ),
                    QAST::Op.new(
                        :op('if'),
                        # condition
                        QAST::Op.new(
                            :op('callmethod'), :name('ast'),
                            QAST::Var.new( :name('$/'), :scope('lexical') )
                        ),
                        # when true
                        QAST::Op.new(
                            :op('callmethod'), :name('ast'),
                            QAST::Var.new( :name('$/'), :scope('lexical') )
                        ),
                        # when false
                        QAST::Op.new(
                            :op('callmethod'), :name('Str'),
                            QAST::Var.new( :name('$/'), :scope('lexical') )
                        )
                    )
                ),
                # And finally evaluate to the smart-match result.
                QAST::Var.new( :name($result_var), :scope('local') )
            );
            $past := QAST::Op.new( :op('locallifetime'), $past, $result_var );
        }
        else {
            my $name := ~$ eq '@' ?? 'cache' !!
                        ~$ eq '%' ?? 'hash' !!
                                            'item';
            # @() and %()
            $past := QAST::Var.new( :name('$/'), :scope('lexical') ) if ~$ eq '';

            $past := QAST::Op.new( :op('callmethod'), :name($name), $past );
        }
        make $past;
    }

    sub make_variable($/, @name) {
        make_variable_from_parts($/, @name, ~$, ~$, ~$);
    }

    sub make_variable_from_parts($/, @name, $sigil, $twigil, $desigilname) {
        my $past := QAST::Var.new( :name(@name[+@name - 1]), :node($/));
        my $name := $past.name();

        if $twigil eq '*' {
            if +@name > 1 {
                $*W.throw($/, 'X::Dynamic::Package', symbol => ~$/);
            }
            $past := QAST::Op.new(
                :op('call'), :name('&DYNAMIC'),
                $*W.add_string_constant($name));
        }
        elsif $twigil eq '?' && $*IN_DECL eq 'variable' && !$*COMPILING_CORE_SETTING {
            $*W.throw($/, 'X::Syntax::Variable::Twigil',
              twigil     => $twigil,
              scope      => $*SCOPE,
              additional => ' because it is reserved'
            );
        }
        elsif $twigil eq '!' {
            # In a declaration, don't produce anything here.
            if $*IN_DECL ne 'variable' {
                setup_attr_var($/, $past);
            }
        }
        elsif $twigil eq '.' && $*IN_DECL ne 'variable' {
            if !$*HAS_SELF {
                $*W.throw($/, ['X', 'Syntax', 'NoSelf'], variable => $name);
            } elsif $*HAS_SELF eq 'partial' {
                $*W.throw($/, ['X', 'Syntax', 'VirtualCall'], call => $name);
            }
            # Need to transform this to a method call.
            $past := $ ?? $.ast !! QAST::Op.new();
            $past.op('callmethod');
            $past.name($desigilname);
            $past.unshift(QAST::Var.new( :name('self'), :scope('lexical') ));
            # Contextualize based on sigil.
            $past := QAST::Op.new(
                :op('callmethod'),
                :name($sigil eq '@' ?? 'list' !!
                      $sigil eq '%' ?? 'hash' !!
                      'item'),
                $past);
        }
        elsif $twigil eq '^' || $twigil eq ':' {
            $past := add_placeholder_parameter($/, $sigil, $desigilname,
                                :named($twigil eq ':'), :full_name($name));
        }
        elsif $twigil eq '~' {
            my $actionsname := $desigilname ~ '-actions';
            $past := QAST::Op.new(
                :op, :name, :returns($*W.find_symbol(['Slang'])),
                QAST::Var.new( :name, :scope ));
            if nqp::existskey(%*LANG, $desigilname) {
                my $wval := QAST::WVal.new( :value(%*LANG{$desigilname}) );
                $wval.named('grammar');
                $past.push($wval);
            }
            if nqp::existskey(%*LANG, $actionsname) {
                my $wval := QAST::WVal.new( :value(%*LANG{$actionsname}) );
                $wval.named('actions');
                $past.push($wval);
            }
        }
        elsif $twigil eq '=' && $desigilname ne 'pod' && $desigilname ne 'finish' {
            $*W.throw($/,
              'X::Comp::NYI', feature => 'Pod variable ' ~ $name);
        }
        elsif $name eq '@_' {
            if $*W.nearest_signatured_block_declares('@_') {
                $past.scope('lexical');
            }
            else {
                $past := add_placeholder_parameter($/, '@', '_',
                                :pos_slurpy(1), :full_name($name));
            }
        }
        elsif $name eq '%_' {
            if $*W.nearest_signatured_block_declares('%_') || $*METHODTYPE {
                $past.scope('lexical');
            }
            else {
                $past := add_placeholder_parameter($/, '%', '_', :named_slurpy(1),
                                :full_name($name));
            }
        }
        elsif $name eq '$?LINE' || $name eq '$?FILE' {
            if $*IN_DECL eq 'variable' {
                $*W.throw($/, 'X::Syntax::Variable::Twigil',
                  twigil => '?',
                  scope  => $*SCOPE,
                );
            }
            if $name eq '$?LINE' {
                $past := $*W.add_constant('Int', 'int', $*W.current_line($/));
            }
            else {
                $past := $*W.add_string_constant($*W.current_file);
            }
        }
        elsif $name eq '&?BLOCK' || $name eq '&?ROUTINE' {
            if $*IN_DECL eq 'variable' {
                $*W.throw($/, 'X::Syntax::Variable::Twigil',
                  twigil => '?',
                  scope  => $*SCOPE,
                );
            }
            my $Routine := $*W.find_symbol(['Routine']);
            if $name eq '&?BLOCK' || nqp::istype($*CODE_OBJECT, $Routine) {
                # Just need current code object.
                $past := QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) );
            }
            else {
                my int $scopes := 0;
                my int $done := 0;
                $past := QAST::Op.new( :op('ctx') );
                until $done {
                    my $co := $*W.get_code_object(:$scopes);
                    if nqp::istype($co, $Routine) {
                        $past := QAST::Op.new(
                            :op('getcodeobj'),
                            QAST::Op.new( :op('ctxcode'), $past )
                        );
                        $done := 1;
                    }
                    elsif !nqp::isconcrete($co) {
                        # Spit out a lexical that we'll fail to look up. Can't just
                        # go and throw because if we're in an interpolated string
                        # we should not complain about this.
                        $past := QAST::Var.new( :name('&?ROUTINE'), :scope('lexical') );
                        $done := 1;
                    }
                    else {
                        $past := QAST::Op.new( :op('ctxouterskipthunks'), $past );
                    }
                    $scopes++;
                }
            }
        }
        elsif +@name > 1 {
            $past := $*W.symbol_lookup(@name, $/, :lvalue(1));
        }
        elsif $*IN_DECL ne 'variable' && (my $attr_alias := $*W.is_attr_alias($name)) {
            $past.name($attr_alias);
            setup_attr_var($/, $past);
        }
        elsif $*IN_DECL ne 'variable' {
            # Expect variable to have been declared somewhere.
            # Locate descriptor and thus type.
            $past.scope('lexical');
            try {
                my $type := $*W.find_lexical_container_type($name);
                $past.returns($type);
                if nqp::objprimspec($type) && !$*W.is_lexical_marked_ro($past.name) {
                    $past.scope('lexicalref');
                }
            }

            # If it's a late-bound sub lookup, we may not find it, so be sure
            # to handle the case where the lookup comes back null.
            if $sigil eq '&' {
                $past := QAST::Op.new(
                    :op('ifnull'), $past,
                    QAST::WVal.new( :value($*W.find_symbol(['Nil'])) ));
            }
        }
        $past
    }

    sub setup_attr_var($/, $past) {
        unless $*HAS_SELF {
            $*W.throw($/, ['X', 'Syntax', 'NoSelf'], variable => $past.name());
        }
        my $attr := $*W.get_attribute_meta_object($/, $past.name(), $past);
        my $type := $attr ?? $attr.type !! NQPMu;
        $past.returns($type) if $attr;
        $past.scope(nqp::objprimspec($type) ?? 'attributeref' !! 'attribute');
        $past.unshift(instantiated_type(['$?CLASS'], $/));
        $past.unshift(QAST::Var.new( :name('self'), :scope('lexical') ));
    }

    method package_declarator:sym($/) { make $.ast; }
    method package_declarator:sym($/)  { make $.ast; }
    method package_declarator:sym($/)   { make $.ast; }
    method package_declarator:sym($/) { make $.ast; }
    method package_declarator:sym($/)    { make $.ast; }
    method package_declarator:sym($/) { make $.ast; }
    method package_declarator:sym($/)  { make $.ast; }

    method package_declarator:sym($/) {
        $*W.apply_trait($/, '&trait_mod:', $*PACKAGE, $.ast);
    }

    method package_declarator:sym($/) {
        $*W.apply_traits($, $*DECLARAND);
    }

    method package_def($/) {
        # Get the body block AST.
        my $block;
        if $ {
            $block := $.ast;
        }
        else {
            $block := $*CURPAD;
            $block.push($.ast);
            $block.node($/);
        }
        $block.blocktype('immediate');

        if $*PKGDECL ne 'role' && $block.ann('placeholder_sig') {
            my $name := $block.ann('placeholder_sig')[0];
            unless $name eq '%_' || $name eq '@_' {
                $name := nqp::concat(nqp::substr($name, 0, 1),
                        nqp::concat('^', nqp::substr($name, 1)));
            }
            $*W.throw( $/, ['X', 'Placeholder', 'Block'],
                placeholder => $name,
            );
        }

        # If it's a stub, add it to the "must compose at some point" list,
        # then just evaluate to the type object. Don't need to do any more
        # just yet.
        if nqp::eqat($[0], '...', 0) {
            unless $*PKGDECL eq 'role' {
                $*W.add_stub_to_check($*PACKAGE);
            }
            $block.blocktype('declaration');
            make QAST::Stmts.new( $block, QAST::WVal.new( :value($*PACKAGE) ) );
            return 1;
        }

        # Handle parametricism for roles.
        if $*PKGDECL eq 'role' {
            # Set up signature. Needs to have $?CLASS as an implicit
            # parameter, since any mention of it is generic.
            my %sig_info := $ ?? $.ast !! hash(parameters => []);
            my @params := %sig_info;
            @params.unshift(hash(
                is_multi_invocant => 1,
                type_captures     => ['$?CLASS', '::?CLASS']
            ));
            my $sig := $*W.create_signature_and_params($, %sig_info, $block, 'Mu');
            add_signature_binding_code($block, $sig, @params);
            $block.blocktype('declaration_static');

            # Need to ensure we get lexical outers fixed up properly. To
            # do this we make a list of closures, which each point to the
            # outer context. These surive serialization and thus point at
            # what has to be fixed up.
            my $throwaway_block_past := QAST::Block.new(
                :blocktype('declaration'),
                QAST::Var.new( :name('$_'), :scope('lexical'), :decl('var') )
            );
            $throwaway_block_past.annotate('outer', $block);
            $block[0].push($throwaway_block_past);
            my $throwaway_block := $*W.create_code_object($throwaway_block_past,
                'Block', $*W.create_signature(nqp::hash('parameter_objects', [])));
            my $fixup := $*W.create_lexical_capture_fixup();
            $fixup.push(QAST::Op.new(
                    :op('p6capturelex'),
                    QAST::Op.new(
                        :op('callmethod'), :name('clone'),
                        QAST::WVal.new( :value($throwaway_block) )
                    )));
            $block[1].push($fixup);

            # As its last act, it should grab the current lexpad so that
            # we have the type environment, and also return the parametric
            # role we're in (because if we land it through a multi-dispatch,
            # we won't know).
            $block[1].push(QAST::Op.new(
                :op('list'),
                QAST::WVal.new( :value($*PACKAGE) ),
                QAST::Op.new( :op('curlexpad') )));

            # Finish code object and add it as the role's body block.
            my $code := $*CODE_OBJECT;
            $*W.attach_signature($code, $sig);
            $*W.finish_code_object($code, $block, 0);
            $*W.add_phasers_handling_code($code, $block);
            $*W.pkg_set_role_body_block($/, $*PACKAGE, $code, $block);

            # Compose before we add the role to the group, so the group sees
            # it composed.
            $*W.pkg_compose($*PACKAGE);

            # Add this role to the group if needed.
            my $group := $*PACKAGE.HOW.group($*PACKAGE);
            unless $group =:= $*PACKAGE {
                $*W.pkg_add_role_group_possibility($/, $group, $*PACKAGE);
            }
        }
        else {
            # Compose.
            $*W.pkg_compose($*PACKAGE);

            # Finish code object for the block.
            my $code := $*CODE_OBJECT;
            $*W.attach_signature($code, $*W.create_signature(nqp::hash('parameter_objects', [])));
            $*W.finish_code_object($code, $block, 0);
            $*W.add_phasers_handling_code($code, $block);
        }

        # check up any private attribute usage
        for %*ATTR_USAGES {
            my $name   := $_.key;
            my @usages := $_.value;
            for @usages {
                my $past := $_;
                my $attr := $*W.get_attribute_meta_object($past.node, $name);
                $past.returns($attr.type);
            }
        }

        # Document
        Perl6::Pod::document($/, $*PACKAGE, $*POD_BLOCK, :leading);
        if ~$*POD_BLOCK ne '' {
            $*POD_BLOCK.set_docee($*PACKAGE);
        }

        make QAST::Stmts.new(
            $block, QAST::WVal.new( :value($*PACKAGE) )
        );
    }

    method scope_declarator:sym($/)      { make $.ast; }
    method scope_declarator:sym($/)     { make $.ast; }
    method scope_declarator:sym($/)     { make $.ast; }
    method scope_declarator:sym($/)    { make $.ast; }
    method scope_declarator:sym($/) { make $.ast; }
    method scope_declarator:sym($/)   { make $.ast; }
    method scope_declarator:sym($/)    { make $.ast; }

    method declarator($/) {
        if    $  { make $.ast  }
        elsif $    { make $.ast    }
        elsif $     { make $.ast     }
        elsif $ {
            my $past := $.ast;
            if $ {
                my $orig_past := $past;
                if $*SCOPE eq 'has' {
                    if $ eq '=' {
                        self.install_attr_init($,
                            $past.ann('metaattr'),
                            $.ast, $*ATTR_INIT_BLOCK);
                    }
                    elsif $ eq '.=' {
                        my $type := $*W.find_symbol([ $*OFTYPE // 'Any']);
                        my $dot_equals := $.ast;
                        $dot_equals.unshift(QAST::WVal.new(:value($type)));
                        $dot_equals.returns($type);
                        self.install_attr_init($,
                            $past.ann('metaattr'),
                            $dot_equals, $*ATTR_INIT_BLOCK);
                    }
                    else {
                        $/.CURSOR.panic("Cannot use " ~ $ ~
                            " to initialize an attribute");
                    }
                }
                elsif $ eq '=' {
                    $past := assign_op($/, $past, $.ast);
                }
                elsif $ eq '.=' {
                    $past := make_dot_equals($past, $.ast);
                }
                else {
                    if nqp::istype($past, QAST::Var) {
                        find_var_decl($*W.cur_lexpad(), $past.name).decl('var');
                    }
                    $past := bind_op($/, $past, $.ast,
                        $ eq '::=');
                }
                if $*SCOPE eq 'state' {
                    $past := QAST::Op.new( :op('if'),
                        QAST::Op.new( :op('p6stateinit') ),
                        $past,
                        $orig_past);
                    $past.annotate('nosink', 1);
                }
            }
            # No initializer, check that the (specified) type accepts the default value.
            elsif $ eq '$' {
                if nqp::istype($past, QAST::Var) {
                    if $*W.cur_lexpad.symbol($past.name) -> %sym {
                        check_default_value_type($/, %sym, %sym, 'variables');
                    }
                }
                elsif $past.ann('metaattr') -> $attr {
                    if !$attr.required && !$attr.type.HOW.archetypes.generic {
                        check_default_value_type($/, $attr.container_descriptor, $attr.type, 'attributes');
                    }
                }
            }
            make $past;
        }
        elsif $ {
            # Go over the params and declare the variable defined in them.
            my $list      := QAST::Op.new( :op('call'), :name('&infix:<,>') );
            my @params    := $.ast;
            my $common_of := $*OFTYPE;
            for @params {
                my $*OFTYPE := $common_of;
                if nqp::existskey($_, 'of_type') && nqp::existskey($_, 'of_type_match') {
                    if $common_of {
                        ($_ // $).CURSOR.typed_sorry(
                            'X::Syntax::Variable::ConflictingTypes',
                            outer => $common_of.ast, inner => $_);
                    }
                    $*OFTYPE := $_;
                    $*OFTYPE.make($_);
                }
                if $_ {
                    my $past := QAST::Var.new( :name($_) );
                    $past := declare_variable($/, $past, $_, $_,
                        $_, $);
                    unless $past.isa(QAST::Op) && $past.op eq 'null' {
                        $list.push($past);
                    }
                }
                else {
                    $*W.handle_OFTYPE_for_pragma($/,'parameters');
                    my %cont_info := $*W.container_type_info($/, $_ || '$',
                        $*OFTYPE ?? [$*OFTYPE.ast] !! [], []);
                    $list.push($*W.build_container_past(
                      %cont_info,
                      $*W.create_container_descriptor(
                        %cont_info, 1, 'anon', %cont_info)));
                }
            }

            if $ {
                my $orig_list := $list;
                if $ eq '=' {
                    $/.CURSOR.panic("Cannot assign to a list of 'has' scoped declarations")
                        if $*SCOPE eq 'has';
                    $list := assign_op($/, $list, $.ast);
                }
                elsif $ eq '.=' {
                    $/.CURSOR.panic("Cannot use .= initializer with a list of declarations");
                }
                else {
                    my %sig_info := $.ast;
                    my $signature := $*W.create_signature_and_params($/, %sig_info, $*W.cur_lexpad(), 'Mu');
                    $list := QAST::Op.new(
                        :op('p6bindcaptosig'),
                        QAST::WVal.new( :value($signature) ),
                        QAST::Op.new(
                            :op('callmethod'), :name('Capture'),
                            $.ast
                        )
                    );
                }
                if $*SCOPE eq 'state' {
                    $list := QAST::Op.new( :op('if'),
                        QAST::Op.new( :op('p6stateinit') ),
                        $list, $orig_list);
                }
            }

            make $list;
        }
        elsif $ {
            # 'my \foo' style declaration
            my $name       :=  $.ast;
            if $*OFTYPE {
                my $type := $*OFTYPE.ast;
                make QAST::Op.new(
                    :op,
                    QAST::Var.new(:$name, :scope),
                    $type =:= $*W.find_symbol(['Mu'])
                        ?? $.ast
                        !! QAST::Op.new(
                            :op('p6bindassert'),
                            $.ast,
                            QAST::WVal.new( :value($type) ),
                        )
                );
            }
            else {
                make QAST::Op.new(
                    :op,
                    QAST::Var.new(:$name, :scope),
                    $.ast
                );
            }
        }
        else {
            $/.CURSOR.panic('Unknown declarator type');
        }
    }

    sub check_default_value_type($/, $descriptor, $bind_constraint, $what) {
        unless nqp::istype($descriptor.default, $bind_constraint) {
            $*W.throw($/, 'X::Syntax::Variable::MissingInitializer',
                type => nqp::how($bind_constraint).name($bind_constraint),
                implicit => !nqp::istype($*OFTYPE, NQPMatch) || !$*OFTYPE && !$*OFTYPE
                         ?? ':' ~ %*PRAGMAS{$what} ~ ' by pragma'
                         !! 0
            );
        }
    }

    method multi_declarator:sym($/) { make $ ?? $.ast !! $.ast }
    method multi_declarator:sym($/) { make $ ?? $.ast !! $.ast }
    method multi_declarator:sym($/)  { make $ ?? $.ast !! $.ast }
    method multi_declarator:sym($/)  { make $.ast }

    method scoped($/) {
        make $.ast;
    }

    method variable_declarator($/) {
        my $past   := $.ast;
        my $sigil  := $;
        my $twigil := $;
        my $desigilname := ~$;
        my $name := $sigil ~ $twigil ~ $desigilname;

        # Don't know why this doesn't work all the time.
        if $desigilname ~~ /\w ':' / {
            $name   := $.ast.name;  # is already canonicalized in 
            $desigilname := nqp::substr($name, nqp::chars($sigil ~ $twigil));
        }

        my @post;
        for $ {
            @post.push($_.ast);
        }
        if $ {
            my $lex := $*W.cur_lexpad();
            if $lex.symbol($name) {
                $/.CURSOR.typed_worry('X::Redeclaration', symbol => $name);
            }
            elsif $lex.ann('also_uses') && $lex.ann('also_uses'){$name} {
                if ~$twigil eq '*' {
                    $/.CURSOR.typed_sorry('X::Dynamic::Postdeclaration', symbol => $name);
                }
                else {
                    $/.CURSOR.typed_sorry('X::Redeclaration::Outer', symbol => $name);
                }
            }
        }
        if nqp::elems($) > 1 {
            $/.CURSOR.panic('Multiple shapes not yet understood');
        }
        make declare_variable($/, $past, ~$sigil, ~$twigil, $desigilname, $, $, :@post);
    }

    sub declare_variable($/, $past, $sigil, $twigil, $desigilname, $trait_list, $shape?, :@post) {
        my $name  := $sigil ~ $twigil ~ $desigilname;
        my $BLOCK := $*W.cur_lexpad();

        my int $have_of_type;
        my $of_type;
        my int $have_is_type;
        my $is_type;

        $*W.handle_OFTYPE_for_pragma($/, $*SCOPE eq 'has' ?? 'attributes' !! 'variables');
        if $*OFTYPE {
            $have_of_type := 1;
            $of_type := $*OFTYPE.ast;
            my $archetypes := $of_type.HOW.archetypes;
            unless $archetypes.nominal || $archetypes.nominalizable || $archetypes.generic || $archetypes.definite {
                $*OFTYPE.CURSOR.typed_sorry('X::Syntax::Variable::BadType', type => $of_type);
            }
        }

        # Process traits for `is Type` and `of Type`, which get special
        # handling by the compiler.
        my @late_traits;
        for $trait_list {
            my $trait := $_.ast;
            if $trait {
                my str $mod := $trait.mod;
                if $mod eq '&trait_mod:' {
                    my $type := $trait.args[0];
                    if $have_of_type {
                        $_.CURSOR.typed_sorry(
                            'X::Syntax::Variable::ConflictingTypes',
                            outer => $of_type, inner => $type)
                    }
                    $have_of_type := 1;
                    $of_type := $type;
                    next;
                }
                if $mod eq '&trait_mod:' {
                    my @args := $trait.args;
                    if nqp::elems(@args) == 1 && !nqp::isconcrete(@args[0]) {
                        $have_is_type := 1;
                        $is_type := @args[0];
                        next;
                    }
                }
                nqp::push(@late_traits, $_);
            }
        }

        if $*SCOPE eq 'has' {
            # Ensure current package can take attributes.
            unless nqp::can($*PACKAGE.HOW, 'add_attribute') {
                if $*PKGDECL {
                    $*W.throw($/, ['X', 'Attribute', 'Package'],
                        package-kind => $*PKGDECL,
                        :$name,
                    );
                } else {
                    $*W.throw($/, ['X', 'Attribute', 'NoPackage'], :$name);
                }
            }

            # Create container descriptor and decide on any default value.
            if $desigilname eq '' {
                $/.CURSOR.panic("Cannot declare an anonymous attribute");
            }
            my $attrname   := ~$sigil ~ '!' ~ $desigilname;
            my %cont_info  := $*W.container_type_info($/, $sigil,
                $have_of_type ?? [$of_type] !! [],
                $have_is_type ?? [$is_type] !! [],
                $shape, :@post);
            my $descriptor := $*W.create_container_descriptor(
              %cont_info, 1, $attrname, %cont_info);

            # Create meta-attribute and add it.
            my $metaattr := $*W.resolve_mo($/, $*PKGDECL ~ '-attr');
            my %config := hash(
                name => $attrname,
                has_accessor => $twigil eq '.',
                container_descriptor => $descriptor,
                type => %cont_info,
                package => $*W.find_symbol(['$?CLASS']));
            if %cont_info {
                %config := $*W.create_thunk($/,
                    %cont_info);
            }
            my $attr := $*W.pkg_add_attribute($/, $*PACKAGE, $metaattr,
                %config, %cont_info, $descriptor);

            # Document it
            Perl6::Pod::document($/, $attr, $*POD_BLOCK, :leading);
            if ~$*POD_BLOCK ne '' {
                $*POD_BLOCK.set_docee($attr);
            }

            # Set it up for trailing declarations
            $*PRECEDING_DECL := $attr;

            # If no twigil, note $foo is an alias to $!foo.
            if $twigil eq '' {
                $BLOCK.symbol($name, :attr_alias($attrname));
            }

            # Apply any traits.
            $*W.apply_traits(@late_traits, $attr);

            # Nothing to emit here; hand back a Nil.
            $past := QAST::WVal.new( :value($*W.find_symbol(['Nil'])) );
            $past.annotate('metaattr', $attr);
        }
        elsif $*SCOPE eq 'my' || $*SCOPE eq 'our' || $*SCOPE eq 'state' {
            # Some things can't be done to our vars.
            my $varname;
            if $*SCOPE eq 'our' {
                if $have_of_type || @post {
                    $/.CURSOR.panic("Cannot put a type constraint on an 'our'-scoped variable");
                }
                elsif $shape {
                    $/.CURSOR.panic("Cannot put a shape on an 'our'-scoped variable");
                }
                elsif $desigilname eq '' {
                    $/.CURSOR.panic("Cannot have an anonymous 'our'-scoped variable");
                }
                if nqp::can($*PACKAGE.HOW, 'archetypes') && $*PACKAGE.HOW.archetypes.parametric {
                    $*W.throw($/, 'X::Declaration::OurScopeInRole',
                        declaration => 'variable'
                    );
                }
            }
            elsif $desigilname eq '' {
                if $twigil {
                    $/.CURSOR.panic("Cannot have an anonymous variable with a twigil");
                }
                $name    := QAST::Node.unique($sigil ~ 'ANON_VAR_');
                $varname := $sigil;
            }

            # Create a container descriptor. Default to rw and set a
            # type if we have one; a trait may twiddle with that later.
            my %cont_info  := $*W.container_type_info($/, $sigil,
                $have_of_type ?? [$of_type] !! [],
                $have_is_type ?? [$is_type] !! [],
                $shape, :@post);
            my $descriptor := $*W.create_container_descriptor(
              %cont_info, 1, $varname || $name, %cont_info);

            # Install the container.
            my $cont := $*W.install_lexical_container($BLOCK, $name, %cont_info, $descriptor,
                :scope($*SCOPE), :package($*PACKAGE));

            # Set scope and type on container, and if needed emit code to
            # reify a generic type or create a fresh container.
            if $past.isa(QAST::Var) {
                my $bind_type := %cont_info;
                $past.name($name);
                $past.returns($bind_type);
                $past.scope(nqp::objprimspec($bind_type) ?? 'lexicalref' !! 'lexical');
                if %cont_info.HOW.archetypes.generic {
                    $past := QAST::Op.new(
                        :op('callmethod'), :name('instantiate_generic'),
                        QAST::Op.new( :op('p6var'), $past ),
                        QAST::Op.new( :op('curlexpad') ));
                }
                elsif %cont_info {
                    if $*SCOPE eq 'state' {
                        $past := QAST::Op.new( :op('if'),
                            QAST::Op.new( :op('p6stateinit') ),
                            QAST::Op.new( :op('bind'), $past, %cont_info ),
                            $past);
                    }
                    else {
                        $past := QAST::Op.new( :op('bind'), $past, %cont_info );
                    }
                }

                if $*SCOPE eq 'our' {
                    $BLOCK[0].push(QAST::Op.new(
                        :op('bind'),
                        $past,
                        $*W.symbol_lookup([$name], $/, :package_only(1), :lvalue(1))
                    ));
                }
            }

            # Twigil handling.
            if $twigil eq '.' {
                add_lexical_accessor($/, $past, $desigilname, $*W.cur_lexpad());
                $name := $sigil ~ $desigilname;
            }
            elsif $twigil eq '!' {
                $*W.throw($/, ['X', 'Syntax', 'Variable', 'Twigil'],
                    twigil => $twigil,
                    scope  => $*SCOPE,
                );
            }

            # Apply any traits.
            if @late_traits {
                my $Variable := $*W.find_symbol(['Variable']);
                my $varvar   := nqp::create($Variable);
                nqp::bindattr_s($varvar, $Variable, '$!name', $name);
                nqp::bindattr_s($varvar, $Variable, '$!scope', $*SCOPE);
                nqp::bindattr($varvar, $Variable, '$!var', $cont);
                nqp::bindattr($varvar, $Variable, '$!block', $*CODE_OBJECT);
                nqp::bindattr($varvar, $Variable, '$!slash', $/);
                $*W.apply_traits(@late_traits, $varvar);
            }
        }
        elsif $*SCOPE eq '' {
            $*W.throw($/, 'X::Declaration::Scope',
                    scope       => '(unknown scope)',
                    declaration => 'variable',
            );
        }
        else {
            $*W.throw($/, 'X::Comp::NYI',
                feature => "$*SCOPE scoped variables");
        }

        $past
    }

    sub add_lexical_accessor($/, $var_past, $meth_name, $install_in) {
        # Generate and install code block for accessor.
        my $a_past := $*W.push_lexpad($/);
        $a_past.name($meth_name);
        $a_past.blocktype('declaration_static');
        $a_past.push($var_past);
        $*W.pop_lexpad();
        $install_in[0].push($a_past);

        # Produce a code object and install it.
        my $invocant_type := $*W.find_symbol([$*W.is_lexical('$?CLASS') ?? '$?CLASS' !! 'Mu']);
        my %sig_info := hash(parameters => []);
        my $signature := $*W.create_signature_and_params($/, %sig_info, $a_past, 'Any',
            :method, :$invocant_type);
        my $code := methodize_block($/, $*W.stub_code_object('Method'),
            $a_past, $signature, %sig_info);
        install_method($/, $meth_name, 'has', $code, $install_in, :gen-accessor);
    }

    method routine_declarator:sym($/) { make $.ast; }
    method routine_declarator:sym($/) { make $.ast; }
    method routine_declarator:sym($/) { make $.ast; }

    method routine_def($/) {
        my $block;

        if $ {
            $block := $.ast;
        }
        else {
            if $ {
                $block := $.ast;
            } else {
                $block := $*CURPAD;
                $block.blocktype('declaration_static');
                $block.push($.ast);
                $block.node($/);
            }
            if is_clearly_returnless($block) {
                $block[1] := QAST::Op.new(
                    :op('p6decontrv'),
                    QAST::WVal.new( :value($*DECLARAND) ),
                    $block[1]);
                $block[1] := wrap_return_type_check($block[1], $*DECLARAND);
            }
            else {
                $block[1] := wrap_return_handler($block[1]);
            }
        }
        $block.blocktype('declaration_static');

        # Attach signature, building placeholder if needed.
        my @params;
        my $signature;
        if $*SIG_OBJ {
            if $block.ann('placeholder_sig') {
                $*W.throw($/, ['X', 'Signature', 'Placeholder'],
                    precursor => '1',
                    placeholder => $block.ann('placeholder_sig')[0],
                );
            }
            @params    := %*SIG_INFO;
            $signature := $*SIG_OBJ;
        }
        else {
            @params := $block.ann('placeholder_sig') || [];
            $signature := $*W.create_signature_and_params($/,
                nqp::hash('parameters', @params), $block, 'Any');
        }
        add_signature_binding_code($block, $signature, @params);

        # Needs a slot that can hold a (potentially unvivified) dispatcher;
        # if this is a multi then we'll need it to vivify to a MultiDispatcher.
        if $*MULTINESS eq 'multi' {
            $*W.install_lexical_symbol($block, '$*DISPATCHER', $*W.find_symbol(['MultiDispatcher']));
        }
        else {
            $block[0].push(QAST::Var.new( :name('$*DISPATCHER'), :scope('lexical'), :decl('var') ));
        }
        $block[0].push(QAST::Op.new(
            :op('takedispatcher'),
            QAST::SVal.new( :value('$*DISPATCHER') )
        ));

        # If it's a proto but not an onlystar, need some variables for the
        # {*} implementation to use.
        if $*MULTINESS eq 'proto' && !$ {
            $block[0].push(QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('CURRENT_DISPATCH_CAPTURE'), :scope('lexical'), :decl('var') ),
                QAST::Op.new( :op('savecapture') )
            ));
            $block[0].push(QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('&*CURRENT_DISPATCHER'), :scope('lexical'), :decl('var') ),
                QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) )
            ));
        }

        # Set name.
        if $ {
            $block.name(~$.ast);
        }

        # Finish code object, associating it with the routine body.
        my $code := $*DECLARAND;
        $*W.attach_signature($code, $signature);
        $*W.finish_code_object($code, $block, $*MULTINESS eq 'proto', :yada(is_yada($/)));

        # attach return type
        if $*OFTYPE {
            my $sig := $code.signature;
            if $sig.has_returns {
                my $prev_returns := $sig.returns;
                $*W.throw($*OFTYPE, 'X::Redeclaration',
                    what    => 'return type for',
                    symbol  => $code,
                    postfix => " (previous return type was "
                                ~ $prev_returns.HOW.name($prev_returns)
                                ~ ')',
                );
            }
            $sig.set_returns($*OFTYPE.ast);
        }

        # Document it
        Perl6::Pod::document($/, $code, $*POD_BLOCK, :leading);
        if ~$*POD_BLOCK ne '' {
            $*POD_BLOCK.set_docee($code);
        }

        # Install PAST block so that it gets capture_lex'd correctly and also
        # install it in the lexpad.
        my $outer := $*W.cur_lexpad();
        my $clone := !($outer =:= $*UNIT);
        $outer[0].push(QAST::Stmt.new($block));

        if $ {
            # If it's a multi, need to associate it with the surrounding
            # proto.
            # XXX Also need to auto-multi things with a proto in scope.
            my $name := '&' ~ ~$.ast;
            if $*MULTINESS eq 'multi' {
                # Do we have a proto in the current scope?
                my $proto;
                if $outer.symbol($name) {
                    $proto := $*W.force_value($outer.symbol($name), $name, 0);
                }
                else {
                    unless $*SCOPE eq '' || $*SCOPE eq 'my' {
                        $*W.throw($/, 'X::Declaration::Scope::Multi',
                            scope       => $*SCOPE,
                            declaration => 'multi',
                        );
                    }
                    # None; search outer scopes.
                    my $new_proto;
                    try {
                        $proto := $*W.find_symbol([$name]);
                    }
                    if $proto && $proto.is_dispatcher {
                        # Found in outer scope. Need to derive.
                        $new_proto := $*W.derive_dispatcher($proto);
                    }
                    else {
                        $new_proto := self.autogenerate_proto($/, $block.name, $outer[0]);
                    }

                    # Install in current scope.
                    $*W.install_lexical_symbol($outer, $name, $new_proto, :$clone);
                    $proto := $new_proto;
                }

                # Ensure it's actually a dispatcher.
                unless nqp::can($proto, 'is_dispatcher') && $proto.is_dispatcher {
                    $*W.throw($/, ['X', 'Redeclaration'],
                        what    => 'routine',
                        symbol  => ~$.ast,
                    );
                }

                # Install the candidate.
                $*W.add_dispatchee_to_proto($proto, $code);
            }
            else {
                # Install.
                my $predeclared := $outer.symbol($name);
                if $predeclared {
                    unless nqp::getattr_i($predeclared, $*W.find_symbol(['Routine']), '$!yada') {
                        $*W.throw($/, ['X', 'Redeclaration'],
                                symbol => ~$.ast,
                                what   => 'routine',
                        );
                    }
                }
                if $*SCOPE eq '' || $*SCOPE eq 'my' {
                    $*W.install_lexical_symbol($outer, $name, $code, :$clone);
                }
                elsif $*SCOPE eq 'our' || $*SCOPE eq 'unit' {
                    # Install in lexpad and in package, and set up code to
                    # re-bind it per invocation of its outer.
                    $*W.install_lexical_symbol($outer, $name, $code, :$clone);
                    my $package := $*PACKAGE;
                    if nqp::existskey($package.WHO, $name) {
                        $*W.throw($/, ['X', 'Redeclaration'],
                            symbol  => ~$.ast,
                            what    => 'routine',
                            postfix => ' (already defined in package ' ~ $package.HOW.name($package) ~ ')'
                        );
                    }
                    $*W.install_package_symbol($/, $package, $name, $code, 'sub');
                    $outer[0].push(QAST::Op.new(
                        :op('bindkey'),
                        QAST::Op.new( :op('who'), QAST::WVal.new( :value($package) ) ),
                        QAST::SVal.new( :value($name) ),
                        QAST::Var.new( :name($name), :scope('lexical') )
                    ));
                }
                elsif $*SCOPE eq 'anon' {
                    # don't do anything
                }
                else {
                    $*W.throw($/, 'X::Declaration::Scope',
                            scope       => $*SCOPE,
                            declaration => 'sub',
                    );
                }
            }
        }
        elsif $*MULTINESS {
            $*W.throw($/, 'X::Anon::Multi', multiness => $*MULTINESS);
        }

        # Apply traits.
        $*W.apply_traits($, $code);
        if $ {
            # Protect with try; won't work when declaring the initial
            # trait_mod proto in CORE.setting!
            try $*W.apply_trait($/, '&trait_mod:', $*DECLARAND, :onlystar(1));
        }

        # Handle any phasers.
        $*W.add_phasers_handling_code($code, $block);

        # Add inlining information if it's inlinable; also mark soft if the
        # appropriate pragma is in effect.
        if $ {
            if %*PRAGMAS {
                $*W.find_symbol(['&infix:'])($code, $*W.find_symbol(['SoftRoutine']));
            }
            elsif !nqp::can($code, 'CALL-ME') {
                my $phasers :=
                  nqp::getattr($code,$*W.find_symbol(['Block']),'$!phasers');
                if nqp::isnull($phasers) || !nqp::p6bool($phasers) {
                    self.add_inlining_info_if_possible($/, $code, $signature, $block, @params);
                }
            }
        }

        # If it's a proto, add it to the sort-at-CHECK-time queue.
        if $*MULTINESS eq 'proto' {
            $*W.add_proto_to_sort($code);
        }

        my $closure := block_closure(reference_to_code_object($code, $block));
        $closure.annotate('sink_ast', QAST::Op.new( :op('null') ));
        make $closure;
    }

    method autogenerate_proto($/, $name, $install_in) {
        my $p_past := $*W.push_lexpad($/);
        $p_past.name(~$name);
        $p_past.is_thunk(1);
        $p_past.push(QAST::Op.new(
            :op('invokewithcapture'),
            QAST::Op.new(
                :op('ifnull'),
                QAST::Op.new(
                    :op('multicachefind'),
                    QAST::Var.new(
                        :name('$!dispatch_cache'), :scope('attribute'),
                        QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) ),
                        QAST::WVal.new( :value($*W.find_symbol(['Routine'])) ),
                    ),
                    QAST::Op.new( :op('usecapture') )
                ),
                QAST::Op.new(
                    :op('callmethod'), :name('find_best_dispatchee'),
                    QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) ),
                    QAST::Op.new( :op('savecapture') )
                ),
            ),
            QAST::Op.new( :op('usecapture') )
        ));
        $*W.pop_lexpad();
        $install_in.push(QAST::Stmt.new($p_past));
        my @p_params := [hash(is_capture => 1, nominal_type => $*W.find_symbol(['Mu']) )];
        my $p_sig := $*W.create_signature(nqp::hash('parameter_objects',
            [$*W.create_parameter($/, @p_params[0])]));
        add_signature_binding_code($p_past, $p_sig, @p_params);
        my $code := $*W.create_code_object($p_past, 'Sub', $p_sig, 1);
        $*W.apply_trait($/, '&trait_mod:', $code, :onlystar(1));
        $*W.add_proto_to_sort($code);
        $code
    }

    my $SIG_ELEM_IS_COPY := 512;
    method add_inlining_info_if_possible($/, $code, $sig, $past, @params) {
        # Make sure the block has the common structure we expect
        # (decls then statements).
        return 0 unless +@($past) == 2;

        # Ensure all parameters are simple and build placeholders for
        # them.
        my $Param  := $*W.find_symbol(['Parameter']);
        my @p_objs := nqp::getattr($sig, $*W.find_symbol(['Signature']), '$!params');
        my int $i  := 0;
        my int $n  := nqp::elems(@params);
        my %arg_placeholders;
        while $i < $n {
            my %info      := @params[$i];
            my $param_obj := @p_objs[$i];
            return 0 if %info || %info || %info ||
                %info || %info || %info || %info ||
                %info || %info || %info ||
                %info || %info;
            my int $flags := nqp::getattr_i($param_obj, $Param, '$!flags');
            return 0 if $flags +& $SIG_ELEM_IS_COPY;
            %arg_placeholders{%info} :=
                QAST::InlinePlaceholder.new( :position($i) );
            $i++;
        }

        # Ensure nothing extra is declared and there are no inner blocks.
        for @($past[0]) {
            if nqp::istype($_, QAST::Var) && $_.scope eq 'lexical' {
                my $name := $_.name;
                return 0 if $name ne '$*DISPATCHER' && $name ne '$_' &&
                    $name ne '$/' && $name ne '$¢' && $name ne '$!' &&
                    !nqp::existskey(%arg_placeholders, $name);
            }
            elsif nqp::istype($_, QAST::Block) {
                return 0;
            }
            elsif nqp::istype($_, QAST::Stmt) && nqp::istype($_[0], QAST::Block) {
                return 0;
            }
        }

        # If all is well, we try to build the QAST for inlining. This dies
        # if we fail.
        my $PseudoStash;
        try $PseudoStash := $*W.find_symbol(['PseudoStash']);
        sub clear_node($qast) {
            $qast.node(nqp::null());
            $qast.clear_annotations();
            $qast
        }
        sub node_walker($node) {
            # Simple values are always fine; just return them as they are, modulo
            # removing any :node(...).
            if nqp::istype($node, QAST::IVal) || nqp::istype($node, QAST::SVal)
            || nqp::istype($node, QAST::NVal) {
                return $node.node ?? clear_node($node.shallow_clone()) !! $node;
            }

            # WVal is OK, though special case for PseudoStash usage (which means
            # we are doing funny lookup stuff).
            elsif nqp::istype($node, QAST::WVal) {
                if $node.value =:= $PseudoStash {
                    nqp::die("Routines using pseudo-stashes are not inlinable");
                }
                else {
                    return $node.node ?? clear_node($node.shallow_clone()) !! $node;
                }
            }

            # Operations need checking for their inlinability. If they are OK in
            # themselves, it comes down to the children.
            elsif nqp::istype($node, QAST::Op) {
                if nqp::getcomp('QAST').operations.is_inlinable('perl6', $node.op) {
                    my $replacement := $node.shallow_clone();
                    my int $i := 0;
                    my int $n := +@($node);
                    while $i < $n {
                        $replacement[$i] := node_walker($node[$i]);
                        $i := $i + 1;
                    }
                    return clear_node($replacement);
                }
                else {
                    nqp::die("Non-inlinable op '" ~ $node.op ~ "' encountered");
                }
            }

            # Variables are fine *if* they are arguments.
            elsif nqp::istype($node, QAST::Var) && ($node.scope eq 'lexical' || $node.scope eq '') {
                if nqp::existskey(%arg_placeholders, $node.name) {
                    my $replacement := %arg_placeholders{$node.name};
                    if $node.named || $node.flat {
                        $replacement := $replacement.shallow_clone();
                        if $node.named { $replacement.named($node.named) }
                        if $node.flat { $replacement.flat($node.flat) }
                    }
                    return $replacement;
                }
                else {
                    nqp::die("Cannot inline with non-argument variables");
                }
            }

            # Statements need to be cloned and then each of the nodes below them
            # visited.
            elsif nqp::istype($node, QAST::Stmt) || nqp::istype($node, QAST::Stmts) {
                my $replacement := $node.shallow_clone();
                my int $i := 0;
                my int $n := +@($node);
                while $i < $n {
                    $replacement[$i] := node_walker($node[$i]);
                    $i := $i + 1;
                }
                return clear_node($replacement);
            }

            # Want nodes need copying and every other child visiting.
            elsif nqp::istype($node, QAST::Want) {
                my $replacement := $node.shallow_clone();
                my int $i := 0;
                my int $n := +@($node);
                while $i < $n {
                    $replacement[$i] := node_walker($node[$i]);
                    $i := $i + 2;
                }
                return clear_node($replacement);
            }

            # Otherwise, we don't know what to do with it.
            else {
                nqp::die("Unhandled node type; won't inline");
            }
        };
        my $inline_info;
        try $inline_info := node_walker($past[1]);
        return 0 unless nqp::istype($inline_info, QAST::Node);

        # Attach inlining information.
        $*W.apply_trait($/, '&trait_mod:', $code, inlinable => $inline_info)
    }

    method method_def($/) {
        my $past;
        if $ {
            $past := $.ast;
        }
        else {
            $past := $.ast;
            if $past.ann('placeholder_sig') {
                $/.PRECURSOR.panic('Placeholder variables cannot be used in a method');
            }
            $past[1] := wrap_return_handler($past[1]);
        }
        $past.blocktype('declaration_static');

        my $name;
        if $ -> $ln {
            if $ln {
                $name := ~$ln;
                for $ln {
                    my $key := $_ || '';
                    if $_ -> $cf {
                        if $cf -> $op_name {
                            $name := $name ~ $*W.canonicalize_pair($key, $*W.colonpair_nibble_to_str(
                                $ln, $op_name // $op_name // $op_name));
                        }
                        else {
                            $name := $name ~ ':' ~ $key;
                        }
                    }
                    else {
                        $name := $name ~ ':' ~ $key;
                    }
                }
            }
            else {
                my $longname := $*W.dissect_longname($);
                $name := $longname.name(:dba('method name'), :decl);
            }
        }
        elsif $ {
            if $ eq '@'    { $name := 'postcircumfix:<[ ]>' }
            elsif $ eq '%' { $name := 'postcircumfix:<{ }>' }
            elsif $ eq '&' { $name := 'postcircumfix:<( )>' }
            else {
                $/.PRECURSOR.panic("Cannot use " ~ $ ~ " sigil as a method name");
            }
        }
        $past.name($name ?? $name !! '');

        my $code := methodize_block($/, $*DECLARAND, $past, $*SIG_OBJ,
            %*SIG_INFO, :yada(is_yada($/)));

        # If it's a proto but not an onlystar, need some variables for the
        # {*} implementation to use.
        if $*MULTINESS eq 'proto' && !$ {
            # Also stash the current lexical dispatcher and capture, for the {*}
            # to resolve.
            $past[0].push(QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('CURRENT_DISPATCH_CAPTURE'), :scope('lexical'), :decl('var') ),
                QAST::Op.new( :op('savecapture') )
            ));
            $past[0].push(QAST::Op.new(
                :op('bind'),
                QAST::Var.new( :name('&*CURRENT_DISPATCHER'), :scope('lexical'), :decl('var') ),
                QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) )
            ));
        }

        # attach return type
        if $*OFTYPE {
            my $sig := $code.signature;
            if $sig.has_returns {
                my $prev_returns := $sig.returns;
                $*W.throw($*OFTYPE, 'X::Redeclaration',
                    what    => 'return type for',
                    symbol  => $code.name,
                    postfix => " (previous return type was "
                                ~ $prev_returns.HOW.name($prev_returns)
                                ~ ')',
                );
            }
            $sig.set_returns($*OFTYPE.ast);
        }


        # Document it
        Perl6::Pod::document($/, $code, $*POD_BLOCK, :leading);
        if ~$*POD_BLOCK ne '' {
            $*POD_BLOCK.set_docee($code);
        }

        # Install PAST block so that it gets capture_lex'd correctly.
        my $outer := $*W.cur_lexpad();
        $outer[0].push($past);

        # Apply traits.
        $*W.apply_traits($, $code);
        if $ {
            $*W.apply_trait($/, '&trait_mod:', $*DECLARAND, :onlystar(1));
        }
        $*W.add_phasers_handling_code($code, $past);

        # Install method.
        if $name {
            my $meta := $ && ~$ eq '^';
            install_method($/, $name, $*SCOPE, $code, $outer, :$meta,
                :private($ && ~$ eq '!'));
        }
        elsif $*MULTINESS {
            $*W.throw($/, 'X::Anon::Multi',
                multiness       => $*MULTINESS,
                routine-type    => 'method',
            );
        }

        # If it's a proto, add it to the sort-at-CHECK-time queue.
        if $*MULTINESS eq 'proto' {
            $*W.add_proto_to_sort($code);
        }

        my $closure := block_closure(reference_to_code_object($code, $past));
        $closure.annotate('sink_ast', QAST::Op.new( :op('null') ));
        make $closure;
    }

    method macro_def($/) {
        my $block;

        $block := $.ast;
        $block.blocktype('declaration_static');
        $block[1] := wrap_return_handler($block[1]);

        # Obtain parameters, create signature object and generate code to
        # call binder.
        if $block.ann('placeholder_sig') && $ {
            $*W.throw($/, 'X::Signature::Placeholder',
                precursor => '1',
                placeholder => $block.ann('placeholder_sig')[0],
            );
        }
        my %sig_info;
        if $ {
            %sig_info := $.ast;
        }
        else {
            %sig_info := $block.ann('placeholder_sig') ?? $block.ann('placeholder_sig') !!
                                                                [];
        }
        my @params := %sig_info;
        my $signature := $*W.create_signature_and_params($ ?? $ !! $/,
            %sig_info, $block, 'Any');
        add_signature_binding_code($block, $signature, @params);

        # Finish code object, associating it with the routine body.
        if $ {
            $block.name(~$.ast);
        }
        my $code := $*DECLARAND;
        $*W.attach_signature($code, $signature);
        $*W.finish_code_object($code, $block, $*MULTINESS eq 'proto');

        # Document it
        Perl6::Pod::document($/, $code, $*POD_BLOCK, :leading);

        # Install PAST block so that it gets capture_lex'd correctly and also
        # install it in the lexpad.
        my $outer := $*W.cur_lexpad();
        $outer[0].push(QAST::Stmt.new($block));

        if $ {
            my $name := '&' ~ ~$.ast;
            # Install.
            if $outer.symbol($name) {
                $/.PRECURSOR.panic("Illegal redeclaration of macro '" ~
                    ~$.ast ~ "'");
            }
            if $*SCOPE eq '' || $*SCOPE eq 'my' {
                $*W.install_lexical_symbol($outer, $name, $code);
            }
            elsif $*SCOPE eq 'our' {
                # Install in lexpad and in package, and set up code to
                # re-bind it per invocation of its outer.
                $*W.install_lexical_symbol($outer, $name, $code);
                $*W.install_package_symbol($/, $*PACKAGE, $name, $code, 'macro');
                $outer[0].push(QAST::Op.new(
                    :op('bind'),
                    $*W.symbol_lookup([$name], $/, :package_only(1)),
                    QAST::Var.new( :name($name), :scope('lexical') )
                ));
            }
            else {
                $/.PRECURSOR.panic("Cannot use '$*SCOPE' scope with a macro");
            }
        }
        elsif $*MULTINESS {
            $/.PRECURSOR.panic('Cannot put ' ~ $*MULTINESS ~ ' on anonymous macro');
        }

        # Apply traits.
        $*W.apply_traits($, $code);
        $*W.add_phasers_handling_code($code, $block);

        my $closure := block_closure(reference_to_code_object($code, $block));
        $closure.annotate('sink_ast', QAST::Op.new( :op('null') ));
        make $closure;
    }

    sub methodize_block($/, $code, $past, $signature, %sig_info, :$yada) {
        # Add signature binding code.
        add_signature_binding_code($past, $signature, %sig_info);

        # Place to store invocant.
        $past[0].unshift(QAST::Var.new( :name('self'), :scope('lexical'), :decl('var') ));
        $past.symbol('self', :scope('lexical'));

        # Needs a slot to hold a multi or method dispatcher.
        $*W.install_lexical_symbol($past, '$*DISPATCHER',
            $*W.find_symbol([$*MULTINESS eq 'multi' ?? 'MultiDispatcher' !! 'MethodDispatcher']));
        $past[0].push(QAST::Op.new(
            :op('takedispatcher'),
            QAST::SVal.new( :value('$*DISPATCHER') )
        ));

        # Finish up code object.
        $*W.attach_signature($code, $signature);
        $*W.finish_code_object($code, $past, $*MULTINESS eq 'proto', :yada($yada));
        $*W.add_phasers_handling_code($code, $past);
        $code
    }

    # Installs a method into the various places it needs to go.
    sub install_method($/, $name, $scope, $code, $outer, :$private, :$meta, :$gen-accessor) {
        my $meta_meth;
        if $private {
            if $*MULTINESS { $/.PRECURSOR.panic("Private multi-methods are not supported"); }
            $meta_meth := 'add_private_method';
        }
        elsif $meta {
            if $*MULTINESS { $/.PRECURSOR.panic("Meta multi-methods are not supported"); }
            $meta_meth := 'add_meta_method';
        }
        else {
            $meta_meth := $*MULTINESS eq 'multi' ?? 'add_multi_method' !! 'add_method';
        }
        if $scope eq '' || $scope eq 'has' {
            # Ensure that current package supports methods, and if so
            # add the method.
            if nqp::can($*PACKAGE.HOW, $meta_meth) {
                $*W.pkg_add_method($/, $*PACKAGE, $meta_meth, $name, $code);
            }
            elsif $gen-accessor {
                $/.PRECURSOR.worry("Useless generation of accessor method in " ~
                    ($*PKGDECL || "mainline"));
            }
            else {
                my $nocando := $*MULTINESS eq 'multi' ?? 'multi-method' !! 'method';
                $/.PRECURSOR.worry(
                    "Useless declaration of a has-scoped $nocando in " ~
                    ($*PKGDECL || "mainline") ~ " (did you mean 'my $*METHODTYPE $name'?)");
            }
        }
        elsif $scope eq 'my' {
            my $mang-name := '&' ~ $name;
            if $outer.symbol($mang-name) {
                $*W.throw($/, ['X', 'Redeclaration'], symbol => $name, what => 'method');
            }
            $*W.install_lexical_symbol($outer, $mang-name, $code, :clone(1));
        }
        elsif $scope eq 'our' {
            my $mang-name := '&' ~ $name;
            if $outer.symbol($mang-name) {
                $*W.throw($/, ['X', 'Redeclaration'], symbol => $name, what => 'method');
            }
            $*W.install_lexical_symbol($outer, $mang-name, $code, :clone(1));
            my $package := $*PACKAGE;
            if nqp::existskey($package.WHO, $name) {
                $*W.throw($/, ['X', 'Redeclaration'],
                    symbol  => $name,
                    what    => 'method',
                    postfix => ' (already defined in package ' ~ $package.HOW.name($package) ~ ')'
                );
            }
            $*W.install_package_symbol($/, $package, '&' ~ $name, $code, 'method');
        }
    }

    sub is_clearly_returnless($block) {
        sub returnless_past($past) {
            return 0 unless
                # It's a simple operation.
                nqp::istype($past, QAST::Op)
                    && nqp::getcomp('QAST').operations.is_inlinable('perl6', $past.op) ||
                # Just a variable lookup.
                nqp::istype($past, QAST::Var) ||
                # Just a QAST::Want
                nqp::istype($past, QAST::Want) ||
                # Just a primitive or world value.
                nqp::istype($past, QAST::WVal) ||
                nqp::istype($past, QAST::IVal) ||
                nqp::istype($past, QAST::NVal) ||
                nqp::istype($past, QAST::SVal);
            for @($past) {
                if nqp::istype($_, QAST::Node) {
                    if !returnless_past($_) {
                        return 0;
                    }
                }
            }
            1;
        }

        # Only analyse things with a single simple statement.
        if +$block[1].list == 1 && nqp::istype($block[1][0], QAST::Stmt) && +$block[1][0].list == 1 {
            # Ensure there's no nested blocks.
            for @($block[0]) {
                if nqp::istype($_, QAST::Block) { return 0; }
                if nqp::istype($_, QAST::Stmts) {
                    for @($_) {
                        if nqp::istype($_, QAST::Block) { return 0; }
                    }
                }
            }

            # Ensure that the PAST is whitelisted things.
            returnless_past($block[1][0][0])
        }
        elsif +$block[1].list == 1 && nqp::istype($block[1][0], QAST::WVal) {
            1
        }
        else {
            0
        }
    }

    sub is_yada($/) {
        if $ && +$ == 1 {
            my $btxt := ~$[0];
            if $btxt ~~ /^ \s* ['...'|'???'|'!!!'|'…'] \s* $/ {
                return 1;
            }
        }
        0
    }

    method onlystar($/) {
        my $BLOCK := $*CURPAD;

        # Remove special variables; no need for them in onlystar.
        my int $i := 0;
        my int $n := +@($BLOCK[0]);
        while $i < $n {
            my $consider := $BLOCK[0][$i];
            if nqp::istype($consider, QAST::Var) {
                my $name := $consider.name;
                if $name eq '$_' || $name eq '$/' || $name eq '$!' || $name eq '$¢' {
                    $BLOCK[0][$i] := QAST::Op.new( :op('null') );
                }
            }
            $i++;
        }

        # Add dispatching code.
        $BLOCK.push(QAST::Op.new(
            :op('invokewithcapture'),
            QAST::Op.new(
                :op('ifnull'),
                QAST::Op.new(
                    :op('multicachefind'),
                    QAST::Var.new(
                        :name('$!dispatch_cache'), :scope('attribute'),
                        QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) ),
                        QAST::WVal.new( :value($*W.find_symbol(['Routine'])) ),
                    ),
                    QAST::Op.new( :op('usecapture') )
                ),
                QAST::Op.new(
                    :op('callmethod'), :name('find_best_dispatchee'),
                    QAST::Op.new( :op('getcodeobj'), QAST::Op.new( :op('curcode') ) ),
                    QAST::Op.new( :op('savecapture') )
                )
            ),
            QAST::Op.new( :op('usecapture') )
        ));
        $BLOCK.node($/);
        $BLOCK.is_thunk(1);
        make $BLOCK;
    }

    method regex_declarator:sym($/, $key?) {
        make $.ast;
    }

    method regex_declarator:sym($/, $key?) {
        make $.ast;
    }

    method regex_declarator:sym($/, $key?) {
        make $.ast;
    }

    method regex_def($/) {
        my $coderef;
        my $name := ~%*RX;
        $*CURPAD.blocktype('declaration_static');
        my %sig_info := $ ?? $[0].ast !! hash(parameters => []);

        if $*MULTINESS eq 'proto' {
            unless $ {
                $/.PRECURSOR.panic("Proto regex body must be \{*\} (or <*> or <...>, which are deprecated)");
            }
            my $proto_body := QAST::Op.new(
                :op('callmethod'), :name('!protoregex'),
                QAST::Var.new( :name('self'), :scope('local') ),
                QAST::SVal.new( :value($name) ));
            $coderef := regex_coderef($/, $*DECLARAND, $proto_body, $*SCOPE, $name, %sig_info, $*CURPAD, $, :proto(1));
        } elsif $.ast {
            $coderef := regex_coderef($/, $*DECLARAND, $.ast, $*SCOPE, $name, %sig_info, $*CURPAD, $);
        }
        else {
            $/.CURSOR.typed_panic("X::Syntax::Regex::NullRegex");
        }

        # Document it
        Perl6::Pod::document($/, $*DECLARAND, $*POD_BLOCK, :leading);
        if ~$*POD_BLOCK ne '' {
            $*POD_BLOCK.set_docee($*DECLARAND);
        }

        # Return closure if not in sink context.
        my $closure := block_closure($coderef);
        $closure.annotate('sink_ast', QAST::Op.new( :op('null') ));
        make $closure;
    }

    sub regex_coderef($/, $code, $qast, $scope, $name, %sig_info, $block, $traits?, :$proto, :$use_outer_match) {
        # Regexes can't have place-holder signatures.
        if $qast.ann('placeholder_sig') {
            $/.PRECURSOR.panic('Placeholder variables cannot be used in a regex');
        }

        # Create a code reference from a regex qast tree
        my $past;
        if $proto {
            $block[1] := $qast;
            $past := $block;
        }
        else {
            $*W.install_lexical_magical($block, '$¢');
            unless $use_outer_match {
                $*W.install_lexical_magical($block, '$/');
            }
            $past := %*RX
                ?? %*LANG.qbuildsub($qast, $block, code_obj => $code)
                !! %*LANG.qbuildsub($qast, $block, code_obj => $code);
        }
        $past.name($name);
        $past.blocktype("declaration_static");

        # Install a $?REGEX (mostly for the benefit of <~~>).
        $block[0].push(QAST::Op.new(
            :op('bind'),
            QAST::Var.new(:name<$?REGEX>, :scope, :decl('var')),
            QAST::Op.new(
                :op('getcodeobj'),
                QAST::Op.new( :op('curcode') )
            )));
        $block.symbol('$?REGEX', :scope);

        # Do the various tasks to turn the block into a method code object.
        my $invocant_type := $*W.find_symbol([ # XXX Maybe Cursor below, not Mu...
            $name && $*SCOPE ne 'my' && $*SCOPE ne 'our' && $*W.is_lexical('$?CLASS') ?? '$?CLASS' !! 'Mu']);
        my $signature := $*W.create_signature_and_params($/, %sig_info, $past, 'Any',
            :method, :$invocant_type);
        methodize_block($/, $code, $past, $signature, %sig_info);

        # Need to put self into a register for the regex engine.
        $past[0].push(QAST::Op.new(
            :op('bind'),
            QAST::Var.new( :name('self'), :scope('local'), :decl('var') ),
            QAST::Var.new( :name('self'), :scope('lexical') )));

        # Install PAST block so that it gets capture_lex'd correctly.
        my $outer := $*W.cur_lexpad();
        $outer[0].push($past);

        # Apply traits.
        $*W.apply_traits($traits, $code) if $traits;

        # Install in needed scopes.
        install_method($/, $name, $scope, $code, $outer) if $name ne '';

        # Bind original source to $!source
        my $Regex  := $*W.find_symbol(['Regex']);
        my $source := ($*METHODTYPE ?? $*METHODTYPE ~ ' ' !! '') ~ $/;
        my $match  := $source ~~ /\s+$/;

        if $match {
            $source := nqp::substr($source, 0, $match.from());
        }
        nqp::bindattr($code, $Regex, '$!source', $source);

        # Return a reference to the code object
        reference_to_code_object($code, $past);
    }

    method type_declarator:sym($/) {
        # Get, or find, enumeration base type and create type object with
        # correct base type.
        my $longname   := $ ?? $*W.dissect_longname($) !! 0;
        my $name       := $ ?? $longname.name() !! $ || '';
        my @name_parts := $ ?? $longname.type_name_parts('enum name', :decl(1)) !! [];

        my $type_obj;
        my sub make_type_obj($base_type) {
            $type_obj := $*W.pkg_create_mo($/, $*W.resolve_mo($/, 'enum'), :$name, :$base_type);
            # Add roles (which will provide the enum-related methods).
            $*W.apply_trait($/, '&trait_mod:', $type_obj, $*W.find_symbol(['Enumeration']));
            if istype($type_obj, $*W.find_symbol(['Numeric'])) {
                $*W.apply_trait($/, '&trait_mod:', $type_obj, $*W.find_symbol(['NumericEnumeration']));
            }
            if istype($type_obj, $*W.find_symbol(['Stringy'])) {
                $*W.apply_trait($/, '&trait_mod:', $type_obj, $*W.find_symbol(['StringyEnumeration']));
            }
            # Apply traits, compose and install package.
            $*W.apply_traits($, $type_obj);
            $*W.pkg_compose($type_obj);
        }
        my $base_type;
        my int $has_base_type := 0;
        if $*OFTYPE {
            $base_type     := $*OFTYPE.ast;
            $has_base_type := 1;
            make_type_obj($base_type);
        }

        if $ {
            $*W.throw($/, 'X::Comp::NYI',
                feature => "Variable case of enums",
            );
        }

        # Get list of either values or pairs; fail if we can't.
        my $Pair := $*W.find_symbol(['Pair']);
        my @values;
        my $term_ast := $.ast;

        # remove val call on a single item
        if $term_ast.isa(QAST::Op) && $term_ast.name eq '&val' {
            $term_ast := $term_ast[0];
        }

        if $term_ast.isa(QAST::Stmts) && +@($term_ast) == 1 {
            $term_ast := $term_ast[0];
        }
        if $term_ast.isa(QAST::Op) && $term_ast.name eq '&infix:<,>' {
            for @($term_ast) {
                my $item_ast := $_;
                if $item_ast.isa(QAST::Op) && $item_ast.name eq '&val' {
                    $item_ast := $item_ast[0];
                }

                if istype($item_ast.returns(), $Pair) && $item_ast[1].has_compile_time_value {
                    @values.push($item_ast);
                }
                elsif $item_ast.has_compile_time_value {
                    @values.push($item_ast);
                }
                else {
                    @values.push($*W.compile_time_evaluate($, $item_ast));
                }
            }
        }
        elsif $term_ast.has_compile_time_value {
            @values.push($term_ast);
        }
        elsif istype($term_ast.returns, $Pair) && $term_ast[1].has_compile_time_value {
            @values.push($term_ast);
        }
        else {
            @values := $*W.compile_time_evaluate($, $.ast).List.FLATTENABLE_LIST;
        }

        # Now we have them, we can go about computing the value
        # for each of the keys, unless they have them supplied.
        # XXX Should not assume integers, and should use lexically
        # scoped &postfix:<++> or so.
        my $cur_value := nqp::box_i(-1, $*W.find_symbol(['Int']));
        my @redecl;
        my $block := $*W.cur_lexpad();
        for @values {
            # If it's a pair, take that as the value; also find
            # key.
            my $cur_key;
            if nqp::istype($_, QAST::Node) && istype($_.returns(), $Pair) {
                $cur_key := $_[1].compile_time_value;
                $cur_value := $*W.compile_time_evaluate($, $_[2]);
                if $has_base_type {
                    unless istype($cur_value, $base_type) {
                        $/.CURSOR.panic("Type error in enum. Got '"
                                ~ $cur_value.HOW.name($cur_value)
                                ~ "' Expected: '"
                                ~ $base_type.HOW.name($base_type)
                                ~ "'"
                        );
                    }
                }
                else {
                    $base_type     :=  $cur_value.WHAT;
                    $has_base_type := 1;
                    make_type_obj($base_type);
                }
            }
            else {
                unless $has_base_type {
                    $base_type := $*W.find_symbol(['Int']);
                    make_type_obj($base_type);
                    $has_base_type := 1;
                }

                if nqp::istype($_, QAST::Node) {
                    $cur_key := $*W.compile_time_evaluate($, $_);
                }
                else {
                    $cur_key := $_;
                }

                $cur_value := $cur_value.succ();
            }
            unless nqp::istype($cur_key, $*W.find_symbol(['Str'])) {
                $cur_key := $cur_key.Str;
            }

            # Create and install value.
            my $val_obj := $*W.create_enum_value($type_obj, $cur_key, $cur_value);
            $cur_key    := nqp::unbox_s($cur_key);
            $*W.install_package_symbol_unchecked($type_obj, $cur_key, $val_obj);
            if $block.symbol($cur_key) {
                nqp::push(@redecl, $cur_key);
                $*W.install_lexical_symbol($block, $cur_key,
                    $*W.find_symbol(['Failure']).new(
                        $*W.find_symbol(['X', 'PoisonedAlias']).new(
                            :alias($cur_key), :package-type, :package-name($name)
                        )
                    )
                );
            }
            else {
                $*W.install_lexical_symbol($block, $cur_key, $val_obj);
            }
            if $*SCOPE eq '' || $*SCOPE eq 'our' {
                $*W.install_package_symbol_unchecked($*PACKAGE, $cur_key, $val_obj);
            }
        }

        if +@redecl -> $amount {
            if $amount > 2 {
                @redecl[$amount - 2] := @redecl[$amount - 2] ~ ' and ' ~ nqp::pop(@redecl);
                $/.CURSOR.typed_worry('X::Redeclaration', symbol => nqp::join(', ', @redecl));
            }
            elsif $amount > 1 {
                $/.CURSOR.typed_worry('X::Redeclaration', symbol => nqp::join(' and ', @redecl));
            }
            else {
                $/.CURSOR.typed_worry('X::Redeclaration', symbol => @redecl[0]);
            }
        }


        # create a type object even for empty enums
        make_type_obj($*W.find_symbol(['Int'])) unless $has_base_type;

        $*W.install_package($/, @name_parts,
            ($*SCOPE || 'our'), 'enum', $*PACKAGE, $block, $type_obj);

        # Compose the added enum values.
        $type_obj.HOW.compose_values($type_obj);

        # Document it
        Perl6::Pod::document($/, $type_obj, $*POD_BLOCK, :leading);
        if ~$*POD_BLOCK ne '' {
            $*POD_BLOCK.set_docee($type_obj);
        }
        # Set it up for trailing declarations
        $*PRECEDING_DECL := $type_obj;

        # We evaluate to the enums values, if we need to.
        my $ast := QAST::Op.new( :op('call'), :name('&ENUM_VALUES'), $term_ast );
        $ast.annotate('sink_ast', QAST::Op.new( :op('null') ));
        make $ast;
    }

    method type_declarator:sym($/) {
        # We refine Any by default; "of" may override.
        my $refinee := $*W.find_symbol([ $*OFTYPE // 'Any']);

        # If we have a refinement, make sure it's thunked if needed. If none,
        # just always true.
        my $refinement := make_where_block($/, $ ?? $.ast !!
            QAST::Op.new( :op('p6bool'), QAST::IVal.new( :value(1) ) ));

        # Create the meta-object.
        my $subset;
        my $longname := $ && $*W.dissect_longname($);
        my @name := $longname ?? $longname.type_name_parts('subset name', :decl(1)) !! [];
        if @name {
            my $target_package := $longname.is_declared_in_global()
                ?? $*GLOBALish
                !! $*PACKAGE;
            my $fullname := $longname.fully_qualified_with($target_package);
            $subset := $*W.create_subset($*W.resolve_mo($/, 'subset'), $refinee, $refinement,
                :name($fullname));
            $*W.install_package($/, @name, ($*SCOPE || 'our'), 'subset',
                $target_package, $*W.cur_lexpad(), $subset);
        }
        else {
            $subset := $*W.create_subset($*W.resolve_mo($/, 'subset'), $refinee, $refinement);
        }

        # Apply traits.
        $*W.apply_traits($, $subset);

        # Document it
        Perl6::Pod::document($/, $subset, $*POD_BLOCK, :leading);
        if ~$*POD_BLOCK ne '' {
            $*POD_BLOCK.set_docee($subset);
        }
        # Set it up for trailing declarations
        $*PRECEDING_DECL := $subset;

        # We evaluate to the refinement type object.
        make QAST::WVal.new( :value($subset) );
    }

    method type_declarator:sym($/) {
        my $value_ast := $.ast;
        my $sigil := '';

        # Provided it's named, install it.
        my $name;
        if $ {
            $name := $.ast;
        }
        elsif $ {
            if $ {
                $sigil := ~$;
                if $sigil eq '@' {
                    $value_ast := QAST::Op.new( :op, :name, $value_ast);
                }
            }
            if $ {
                my $twigil := ~$;
                if $twigil eq '?' {
                    unless $*COMPILING_CORE_SETTING {
                        $*W.throw($/, 'X::Comp::NYI',
                          feature => "Constants with a '$twigil' twigil"
                        );
                    }
                }

                elsif $twigil eq '*' {
                    $*W.throw($/, 'X::Syntax::Variable::Twigil',
                      what       => 'constant',
                      twigil     => $twigil,
                      scope      => $*SCOPE,
                      additional => ' because dynamic constants are an oxymoron'
                    );
                }

                # Don't handle other twigil'd case yet.
                else {
                    $*W.throw($/, 'X::Comp::NYI',
                      feature => "Constants with a '$twigil' twigil");
                }
            }
            $name := ~$;
        }

        # Get constant value.
        my $type := $*W.find_symbol([ $*OFTYPE // 'Any']);
        if $ eq '.=' {
            $value_ast.unshift(QAST::WVal.new(:value($type)));
        }
        $value_ast.returns($type);

        my $con_block := $*W.pop_lexpad();
        my $value;
        if $value_ast.has_compile_time_value {
            $value := $value_ast.compile_time_value;
        }
        else {
            $con_block.push($value_ast);
            my $value_thunk := $*W.create_simple_code_object($con_block, 'Block');
            $value := $*W.handle-begin-time-exceptions($/, 'evaluating a constant', $value_thunk);
            $*W.add_constant_folded_result($value);
        }
        if $sigil eq '%' {
            my $Associative := $*W.find_symbol(['Associative']);
            if !nqp::istype($value, $Associative) {
                $*W.throw($/, 'X::TypeCheck',
                    operation => "constant declaration of " ~ ~$,
                    expected => $Associative, got => $*W.find_symbol([$value.HOW.name($value)]) );
            }
        }

        if $name {
            my $cur_pad := $*W.cur_lexpad();
            if $cur_pad.symbol($name) {
                $*W.throw($/, ['X', 'Redeclaration'], symbol => $name);
            }

            $*W.install_package($/, [$name], ($*SCOPE || 'our'),
                'constant', $*PACKAGE, $cur_pad, $value);
        }
        for $ {
            $_.ast.apply($value, :SYMBOL($name)) if $_.ast;
        }

        # Evaluate to the constant.
        make QAST::WVal.new( :value($value), :returns($type) );
    }

    method initializer:sym<=>($/) {
        make $.ast;
    }
    method initializer:sym<:=>($/) {
        make $.ast;
    }
    method initializer:sym<::=>($/) {
        make $.ast;
    }
    method initializer:sym<.=>($/) {
        make $.ast;
    }

    method initializer:sym<.>($/) {
        make $.ast;
    }

    method capterm($/) {
        my $past := $
            ?? QAST::Op.new( $.ast )
            !! $.ast;
        $past.unshift(QAST::WVal.new( :value($*W.find_symbol(['Capture']) ) ));
        $past.op('callmethod');
        $past.name('from-args');
        make $past;
    }

    method multisig($/) {
        make $.ast;
    }

    method fakesignature($/) {
        my $fake_pad := $*W.pop_lexpad();
        my $sig := $*W.create_signature_and_params($/, $.ast,
            $fake_pad, 'Mu', :no_attr_check(1));

        $*W.cur_lexpad()[0].push($fake_pad);
        $*W.create_code_object($fake_pad, 'Block', $sig);

        make QAST::WVal.new( :value($sig) );
    }

    method signature($/) {
        # Fix up parameters with flags according to the separators.
        my %signature;
        my @parameter_infos;
        my int $param_idx := 0;
        for $ {
            my %info := $_.ast;
            my $sep := @*seps[$param_idx];
            if ~$sep eq ':' {
                if $param_idx != 0 {
                    $*W.throw($/, 'X::Syntax::Signature::InvocantMarker')
                }
                unless $*ALLOW_INVOCANT {
                    $*W.throw($/, 'X::Syntax::Signature::InvocantNotAllowed')
                }
                %info := 1;
            }
            @parameter_infos.push(%info);
            $param_idx := $param_idx + 1;
        }
        %signature := @parameter_infos;
        if $ {
            %signature := $.ast;
        }
        elsif $ {
            %signature := $.ast.compile_time_value;
        }

        # Mark current block as having a signature.
        $*W.mark_cur_lexpad_signatured();

        # Result is set of parameter descriptors.
        make %signature;
    }

    method parameter($/) {
        # If it's a defterm, need to do parameter setup here.
        if $ {
            my $name := $.ast;
            %*PARAM_INFO := $name;
            %*PARAM_INFO   := $name;
            %*PARAM_INFO         := '';
            self.declare_param($/, $name);
        }

        # Sanity checks.
        my $quant := $;
        if $ {
            my $name := %*PARAM_INFO // '';
            if $quant eq '*' {
                $/.CURSOR.typed_sorry('X::Parameter::Default', how => 'slurpy',
                            parameter => $name);
            }
            if $quant eq '!' {
                $/.CURSOR.typed_sorry('X::Parameter::Default', how => 'required',
                            parameter => $name);
            }
            my $val := $[0].ast;
            if $val.has_compile_time_value {
                my $value := $val.compile_time_value;
                check_param_default_type($/, $value);
                %*PARAM_INFO := $value;
                %*PARAM_INFO := 1;
            }
            else {
                my $maybe_code_obj := $val.ann('code_object');
                if nqp::isconcrete($maybe_code_obj) {
                    check_param_default_type($/, $maybe_code_obj);
                }
                %*PARAM_INFO :=
                    $*W.create_thunk($[0], $val);
            }
        }

        # Set up various flags.
        %*PARAM_INFO   := $quant eq '*' && %*PARAM_INFO eq '@';
        %*PARAM_INFO      := $quant eq '**' && %*PARAM_INFO eq '@';
        %*PARAM_INFO := $quant eq '*' && %*PARAM_INFO eq '%';
        %*PARAM_INFO     := $quant eq '?' || $ || ($ && $quant ne '!');
        %*PARAM_INFO       := $quant eq '\\' || ($quant eq '+' && !%*PARAM_INFO);
        %*PARAM_INFO   := $quant eq '|';
        %*PARAM_INFO   := $quant eq '+';

        # Stash any traits.
        %*PARAM_INFO := $;

        if $ {
            if %*PARAM_INFO || %*PARAM_INFO || %*PARAM_INFO {
                $/.CURSOR.typed_sorry('X::Parameter::TypedSlurpy', kind => 'positional');
            }
            elsif %*PARAM_INFO {
                $/.CURSOR.typed_sorry('X::Parameter::TypedSlurpy', kind => 'named');
            }
        }

        # Result is the parameter info hash.
        make %*PARAM_INFO;
    }

    sub check_param_default_type($/, $value) {
        if nqp::existskey(%*PARAM_INFO, 'nominal_type') {
            my $expected := %*PARAM_INFO;
            if nqp::objprimspec($expected) == 0 {
                unless nqp::istype($value, $expected) {
                    # Ensure both types are composed before complaining,
                    # or we give spurious errors on stubbed things or
                    # things we're in the middle of compiling.
                    my $got_comp := try $value.HOW.is_composed($value);
                    my $exp_comp := try $expected.HOW.is_composed($expected);
                    if $got_comp && $exp_comp {
                        $[0].CURSOR.typed_sorry(
                            'X::Parameter::Default::TypeCheck',
                            got => $value,
                            expected => %*PARAM_INFO);
                    }
                }
            }
        }
    }

    method param_var($/) {
        if $ {
            if nqp::existskey(%*PARAM_INFO, 'sub_signature_params') {
                $/.CURSOR.panic('Cannot have more than one sub-signature for a parameter');
            }
            %*PARAM_INFO := $.ast;
            if nqp::eqat(~$/, '[', 0) {
                %*PARAM_INFO := '@';
                %*PARAM_INFO := $*W.find_symbol(['Positional']);
            }
        }
        else {
            # Set name, if there is one.
            if $ {
                %*PARAM_INFO := ~$/;
                %*PARAM_INFO := ~$;
            }
            %*PARAM_INFO := my $sigil := ~$;

            # Depending on sigil, use appropriate role.
            my int $need_role;
            my $role_type;
            if $sigil eq '@' {
                $role_type := $*W.find_symbol(['Positional']);
                $need_role := 1;
            }
            elsif $sigil eq '%' {
                $role_type := $*W.find_symbol(['Associative']);
                $need_role := 1;
            }
            elsif $sigil eq '&' {
                $role_type := $*W.find_symbol(['Callable']);
                $need_role := 1;
            }
            if $need_role {
                if nqp::existskey(%*PARAM_INFO, 'nominal_type') {
                    %*PARAM_INFO := $*W.parameterize_type_with_args($/,
                        $role_type, [%*PARAM_INFO], nqp::hash());
                }
                else {
                    %*PARAM_INFO := $role_type;
                }
            }

            # Handle twigil.
            my $twigil := $ ?? ~$ !! '';
            %*PARAM_INFO := $twigil;
            if $twigil eq '' || $twigil eq '*' {
                # Need to add the name.
                if $ {
                    my $name := ~$/;
                    if $ {
                        $name := nqp::substr($name, 0, nqp::chars($name) - nqp::chars(~$));
                        %*PARAM_INFO := $name;
                    }
                    self.declare_param($/, $name);
                }
            }
            elsif $twigil eq '!' {
                if !$*HAS_SELF && $*SURROUNDING_DECL ne 'variable' {
                    $*W.throw($/, ['X', 'Syntax', 'NoSelf'], variable => ~$/);
                }
                %*PARAM_INFO := 1;
                my int $succ := 1;
                try {
                    %*PARAM_INFO := $*W.find_symbol(['$?CLASS']);
                    CATCH {
                        $succ := 0;
                    }
                }
                unless $succ {
                    $/.CURSOR.panic('cannot use a $! parameter in a signature where no $?CLASS is available');
                }
            }
            elsif $twigil eq '.' {
                if $*SURROUNDING_DECL ne 'variable' {
                    if !$*HAS_SELF {
                        $*W.throw($/, ['X', 'Syntax', 'NoSelf'], variable => ~$/);
                    }
                    elsif $*HAS_SELF eq 'partial' {
                        $*W.throw($/, ['X', 'Syntax', 'VirtualCall'], call => ~$/);
                    }
                }
                %*PARAM_INFO := 1;
                if $ {
                    %*PARAM_INFO := ~$;
                }
                else {
                    $/.CURSOR.panic("Cannot declare $. parameter in signature without an accessor name");
                }
            }
            else {
                if $twigil eq ':' {
                    $/.CURSOR.typed_sorry('X::Parameter::Placeholder',
                        parameter => ~$/,
                        right     => ':' ~ $ ~ ~$,
                    );
                }
                else {
                    $/.CURSOR.typed_sorry('X::Parameter::Twigil',
                        parameter => ~$/,
                        twigil    => $twigil,
                    );
                }
            }
        }
        # Handle leading declarative docs
        if $*DECLARATOR_DOCS ne '' {
            %*PARAM_INFO := $*POD_BLOCK;
            $*DECLARATOR_DOCS  := '';
        }

        # Attach the dummy param we set up in Grammar::param_var to PARAM_INFO,
        # so we can access it later on.  The dummy param may have goodies like
        # trailing docs!
        my $par_type := $*W.find_symbol(['Parameter']);
        if nqp::istype($*PRECEDING_DECL, $par_type) {
            %*PARAM_INFO := $*PRECEDING_DECL;
        }

        if $ {
            unless %*PARAM_INFO {
                %*PARAM_INFO := [];
            }
            my $get_signature_past := QAST::Op.new(
                :op('callmethod'),
                :name('signature'),
                QAST::Var.new( :name('$_'), :scope('lexical') )
            );
            my $closure_signature := $.ast;

            my $where := make_where_block($/, $closure_signature, $get_signature_past);
            %*PARAM_INFO.push($where);
        }

        if $ {
            unless %*PARAM_INFO {
                %*PARAM_INFO := [];
            }
            my $where := make_where_block($,
                QAST::Op.new(
                    :op('callmethod'), :name('list'),
                    $.ast),
                QAST::Op.new(
                    :op('if'),
                    QAST::Op.new(
                        :op('can'),
                        QAST::Var.new( :name('$_'), :scope('lexical') ),
                        QAST::SVal.new( :value('shape') )
                    ),
                    QAST::Op.new(
                        :op('callmethod'), :name('shape'),
                        QAST::Var.new( :name('$_'), :scope('lexical') )
                    )));
            %*PARAM_INFO.push($where);
        }
    }

    method declare_param($/, $name) {
        my $cur_pad := $*W.cur_lexpad();
        if $cur_pad.symbol($name) {
            $*W.throw($/, ['X', 'Redeclaration'], symbol => $name);
        }
        if nqp::existskey(%*PARAM_INFO, 'nominal_type') {
            $cur_pad[0].push(QAST::Var.new( :$name, :scope('lexical'),
                :decl('var'), :returns(%*PARAM_INFO) ));
            %*PARAM_INFO := $*W.create_container_descriptor(
                %*PARAM_INFO, 0, %*PARAM_INFO);
            $cur_pad.symbol(%*PARAM_INFO, :descriptor(%*PARAM_INFO),
                :type(%*PARAM_INFO));
        } else {
            $cur_pad[0].push(QAST::Var.new( :name($name), :scope('lexical'), :decl('var') ));
        }
        $cur_pad.symbol($name, :scope('lexical'));
    }

    method named_param($/) {
        %*PARAM_INFO := %*PARAM_INFO || [];
        if $               { %*PARAM_INFO.push(~$); }
        elsif $ { %*PARAM_INFO.push(~$); }
        else                     { %*PARAM_INFO.push(''); }
    }

    method default_value($/) {
        make $.ast;
    }

    method type_constraint($/) {
        if $ {
            my str $typename := ~$;
            if nqp::eqat($typename, '::', 0) && !nqp::eqat($typename, '?', 2) {
                # Set up signature so it will find the typename.
                my $desigilname := nqp::substr($typename, 2);
                unless %*PARAM_INFO {
                    %*PARAM_INFO := []
                }
                %*PARAM_INFO.push($desigilname);

                # Install type variable in the static lexpad. Of course,
                # we'll find the real thing at runtime, but in the static
                # view it's a type variable to be reified.
                $*W.install_lexical_symbol($*W.cur_lexpad(), $desigilname,
                    $.ast);
            }
            else {
                if nqp::existskey(%*PARAM_INFO, 'nominal_type') {
                    $*W.throw($/, ['X', 'Parameter', 'MultipleTypeConstraints'],
                        parameter => (%*PARAM_INFO // ''),
                    );
                }
                my $type := $.ast;
                if nqp::isconcrete($type) {
                    # Actual a value that parses type-ish.
                    %*PARAM_INFO := $type.WHAT;
                    unless %*PARAM_INFO {
                        %*PARAM_INFO := [];
                    }
                    %*PARAM_INFO.push($type);
                }
                elsif $type.HOW.archetypes.nominal {
                    %*PARAM_INFO := $type;
                }
                elsif $type.HOW.archetypes.coercive {
                    %*PARAM_INFO := $type.HOW.constraint_type($type);
                    %*PARAM_INFO  := $type.HOW.target_type($type);
                }
                elsif $type.HOW.archetypes.definite {
                    %*PARAM_INFO := $type.HOW.base_type($type);
                }
                elsif $type.HOW.archetypes.generic {
                    %*PARAM_INFO := $type;
                    %*PARAM_INFO := 1;
                }
                elsif $type.HOW.archetypes.nominalizable {
                    my $nom := $type.HOW.nominalize($type);
                    %*PARAM_INFO := $nom;
                    unless %*PARAM_INFO {
                        %*PARAM_INFO := [];
                    }
                    %*PARAM_INFO.push($type);
                }
                else {
                    $.CURSOR.typed_sorry('X::Parameter::BadType', :$type);
                }
                %*PARAM_INFO := %*PARAM_INFO;
                %*PARAM_INFO := $;
                %*PARAM_INFO   := 1 if $;
                %*PARAM_INFO := 1 if $;
            }
        }
        elsif $ {
            if nqp::existskey(%*PARAM_INFO, 'nominal_type') {
                $*W.throw($/, ['X', 'Parameter', 'MultipleTypeConstraints'],
                        parameter => (%*PARAM_INFO // ''),
                );
            }
            my $ast := $.ast;
            my $val;
            if nqp::can($ast,'has_compile_time_value') && $ast.has_compile_time_value {
                $val := $ast.compile_time_value;
            }
            else {  # for negatives
                my $i  := $*W.add_numeric_constant(NQPMu, 'Int', +$.Str);
                $val := $i.compile_time_value;
            }
            %*PARAM_INFO := $val.WHAT;
            unless %*PARAM_INFO {
                %*PARAM_INFO := [];
            }
            %*PARAM_INFO.push($val);
        }
        else {
            $/.CURSOR.panic('Cannot do non-typename cases of type_constraint yet');
        }
    }

    method post_constraint($/) {
        if $*CONSTRAINT_USAGE eq 'param' {
            if $ {
                if nqp::existskey(%*PARAM_INFO, 'sub_signature_params') {
                    $/.CURSOR.panic('Cannot have more than one sub-signature for a parameter');
                }
                %*PARAM_INFO := $.ast;
                if nqp::eqat(~$/, '[', 0) {
                    %*PARAM_INFO := '@' unless %*PARAM_INFO;
                }
            }
            else {
                unless %*PARAM_INFO {
                    %*PARAM_INFO := [];
                }
                %*PARAM_INFO.push(make_where_block($/, $.ast));
            }
        }
        else {
            if $ {
                $/.CURSOR.NYI('Signatures as constraints on variables');
            }
            else {
                make make_where_block($/, $.ast);
            }
        }
    }

    method trait($/) {
        make $ ?? $.ast !! $.ast;
    }

    my class Trait {
        has $!match;
        has str $!trait_mod;
        has @!pos_args;
        has %!named_args;

        method new($match, str $trait_mod, *@pos_args, *%named_args) {
            my $self := nqp::create(self);
            nqp::bindattr($self, Trait, '$!match', $match);
            nqp::bindattr_s($self, Trait, '$!trait_mod', $trait_mod);
            nqp::bindattr($self, Trait, '@!pos_args', @pos_args);
            nqp::bindattr($self, Trait, '%!named_args', %named_args);
            $self
        }

        method apply($declarand, *%additional) {
            $*W.apply_trait($!match, $!trait_mod, $declarand, |@!pos_args,
                |%!named_args, |%additional);
        }

        method mod() { $!trait_mod }
        method args() { @!pos_args }
    }

    method trait_mod:sym($/) {
        # Handle is repr specially.
        if ~$ eq 'repr' {
            if $ {
                if nqp::istype($[0].ast, QAST::WVal) {
                    $*REPR := compile_time_value_str($[0].ast, "is repr(...) trait", $/);
                } else {
                    $*REPR := compile_time_value_str($[0].ast[0], "is repr(...) trait", $/);
                }
            }
            else {
                $/.CURSOR.panic("is repr(...) trait needs a parameter");
            }
        }
        else
        {
            # If we have an argument, get its compile time value or
            # evaluate it to get that.
            my @trait_arg;
            if $ {
                my $arg := $[0].ast;
                if nqp::istype($arg, QAST::Want) {
                    $arg := $arg[0];
                }

                @trait_arg[0] := $arg.has_compile_time_value ??
                    $arg.compile_time_value !!
                    $*W.create_thunk($/, $[0].ast)();
            }

            # If we have a type name then we need to dispatch with that type; otherwise
            # we need to dispatch with it as a named argument.
            my @name := $*W.dissect_longname($).components();
            if $*W.is_name(@name) {
                my $trait := $*W.find_symbol(@name);
                make Trait.new($/, '&trait_mod:', $trait, |@trait_arg);
            }
            else {
                my %arg;
                %arg{~$} := @trait_arg ?? @trait_arg[0] !!
                    $*W.find_symbol(['Bool', 'True']);
                make Trait.new($/, '&trait_mod:', |%arg);
            }
        }
    }

    method trait_mod:sym($/) {
        make Trait.new($/, '&trait_mod:', $.ast);
    }

    method trait_mod:sym($/) {
        make Trait.new($/, '&trait_mod:', $.ast);
    }

    method trait_mod:sym($/) {
        my %arg;
        %arg{~$} := ($*W.add_constant('Int', 'int', 1)).compile_time_value;
        make Trait.new($/, '&trait_mod:', ($.ast).ann('code_object'), |%arg);
    }

    method trait_mod:sym($/) {
        make Trait.new($/, '&trait_mod:', $.ast);
    }

    method trait_mod:sym($/) {
        make Trait.new($/, '&trait_mod:', $.ast);
    }

    method trait_mod:sym($/) {
        make Trait.new($/, '&trait_mod:', $.ast);
    }

    method trait_mod:sym($/) {
        # The term may be fairly complex. Thus we make it into a thunk
        # which the trait handler can use to get the term and work with
        # it.
        my $thunk := $*W.create_thunk($/, $.ast);
        make Trait.new($/, '&trait_mod:', $thunk);
    }

    method postop($/) {
        if $ {
            make $.ast
                 || QAST::Op.new( :name('&postfix' ~ $*W.canonicalize_pair('', $.Str)), :op )
        } else {
            make $.ast
                 || QAST::Op.new( :name('&postcircumfix' ~ $*W.canonicalize_pair('', $.Str)), :op );
        }
    }

    method dotty:sym<.>($/) { make $.ast; }

    method dotty:sym<.*>($/) {
        my $past := $.ast;
        unless $past.isa(QAST::Op) && $past.op() eq 'callmethod' {
            $/.CURSOR.panic("Cannot use " ~ $.Str ~ " on a non-identifier method call");
        }
        if $ eq '.^' {
            $past.op('p6callmethodhow');
        }
        else {
            $past.unshift($*W.add_string_constant($past.name))
                if $past.name ne '';
            $past.name('dispatch' ~ $*W.canonicalize_pair('', ~$));
        }
        make $past;
    }

    method dottyop($/) {
        if $ {
            make $.ast;
        }
        elsif $ {
            make $.ast;
        }
        else {
            if $ eq "" && $ -> $cf {
                if $cf -> $op_name {
                    make QAST::Op.new( :op, :node($/),
                    :name('&prefix' ~
                    $*W.canonicalize_pair('', $*W.colonpair_nibble_to_str(
                        $/, $op_name // $op_name // $op_name
                    ))));
                }
            } else {
                make $.ast;
            }
        }
    }

    method privop($/) {
        # Compiling private method calls is somewhat interesting. If it's
        # in any way qualified, we need to ensure that the current package
        # is trusted by the target class. Otherwise we assume that the call
        # is to a private method in the current (non-virtual) package.
        # XXX Attribute accesses? Again, maybe for the optimizer, since it
        # runs after CHECK time.
        my $past := $.ast;
        if $ {
            my @parts   := $*W.dissect_longname($).components();
            my $name    := @parts.pop;
            if @parts {
                my $methpkg := $*W.find_symbol(@parts);
                unless nqp::can($methpkg.HOW, 'is_trusted') && $methpkg.HOW.is_trusted($methpkg, $*PACKAGE) {
                    $*W.throw($/, ['X', 'Method', 'Private', 'Permission'],
                        :method(         $name),
                        :source-package( $methpkg.HOW.name($methpkg)),
                        :calling-package( $*PACKAGE.HOW.name($*PACKAGE)),
                    );
                }
                $past[1].returns($methpkg);
            }
            else {
                my $pkg := $*PACKAGE;
                unless nqp::can($pkg.HOW, 'find_private_method') {
                    $*W.throw($/, ['X', 'Method', 'Private', 'Unqualified'],
                        :method($name),
                    );
                }
                if $pkg.HOW.archetypes.parametric {
                    $past.unshift(QAST::Var.new( :name('::?CLASS'), :scope('typevar') ));
                }
                else {
                    $past.unshift(QAST::WVal.new( :value($pkg) ));
                    $past[0].returns($pkg);
                }
                $past.unshift($*W.add_string_constant($name));
            }
            $past.name('dispatch:');
        }
        elsif $ {
            my $name := $past.shift;
            my $pkg  := $*PACKAGE;
            if $pkg.HOW.archetypes.parametric {
                $past.unshift(QAST::Var.new( :name('::?CLASS'), :scope('typevar') ));
            }
            else {
                $past.unshift(QAST::WVal.new( :value($*PACKAGE) ));
            }
            $past.unshift($name);
            $past.name('dispatch:');
        }
        else {
            $/.CURSOR.panic("Cannot use this form of method call with a private method");
        }
        make $past;
    }

    method methodop($/) {
        my $past := $ ?? $.ast !! QAST::Op.new( :node($/) );
        $past.op('callmethod');
        my $name;
        if $ {
            # May just be .foo, but could also be .Foo::bar. Also handle the
            # macro-ish cases.
            my @parts := $*W.dissect_longname($).components();
            $name := @parts.pop;
            if +@parts {
                $past.unshift($*W.symbol_lookup(@parts, $/));
                $past.unshift($*W.add_string_constant($name));
                $past.name('dispatch:<::>');
                make $past;
                return;
            }
        }
        elsif $ {
            $name := ~$;
        }
        else {
            $name := '';
        }

        if $name ne '' {
            if $name eq 'WHAT' {
                whine_if_args($/, $past, $name);
                $past.op('what');
            }
            elsif $name eq 'HOW' {
                whine_if_args($/, $past, $name);
                $past.op('how');
            }
            elsif $name eq 'WHO' {
                whine_if_args($/, $past, $name);
                $past.op('who');
            }
            elsif $name eq 'VAR' {
                whine_if_args($/, $past, $name);
                $past.op('p6var');
            }
            elsif $name eq 'REPR' {
                whine_if_args($/, $past, $name);
                $past.op('p6reprname');
            }
            elsif $name eq 'DEFINITE' {
                whine_if_args($/, $past, $name);
                $past.op('p6definite');
            }
            else {
                $past.name( $name );
            }
        }
        elsif $ {
            $past.unshift(
                QAST::Op.new(
                    :op,
                    $.ast
                )
            );
        }
        elsif $ {
            $past.unshift($.ast);
            $past.name('dispatch:');
        }
        make $past;
    }

    sub whine_if_args($/, $past, $name) {
        if +@($past) > 0 {
           $*W.throw($/, ['X', 'Syntax', 'Argument', 'MOPMacro'], macro => $name);
        }
    }

    method term:sym<::?IDENT>($/) {
        make instantiated_type([~$/], $/);
    }

    method term:sym($/) {
        make QAST::Var.new( :name('self'), :scope('lexical'), :returns($*PACKAGE), :node($/) );
    }

    method term:sym($/) {
        make QAST::Op.new( :op('call'), :name('&term:'), :node($/) );
    }

    method term:sym