Pugs

Day 108: Assorted hackings.

This now works, much to the joy to pad walkers everywhere:

my $x = 1;
{ my $x = 2; say $x + $OUTER::x }   # 3

I looked briefly at Mono, CIL and Mondrian/Haskell.NET today. It looks like I can't easily get Mondrian working on Mono or reuse its code, so Pugs.Compile.CIL does not look as attractive as it first seemed to be. Hmm, maybe Pugs.Compile.Perl5 is more attractive after all...

iblech implemented Perl 5-like behaviour for warn(), die() as well as warn("...\n") and die("...\n").

Yesterday's infix operator fix broke lots of tests, because all loose infix operators are made into tight ones. It caused Limbic_Region some troubles, but has been sorted out in the end.

Hacking on [...] autogeneration continued; it now works for user-defined infix subroutines, so defining infix:<Z> will yield a prefix:<[Z]> for free. However, the base operator's associativity is not yet respected -- it's all foldl now -- but it will be fixed. Update -- it's now fixed, two hours later.

I discovered that [=>] 1..10 can efficiently build linked lists dear to functional programmers.

iblech implemented a p6explain script, to explain what a complicated operator may mean. He is also working on a p6bible script, ported from Perl 5 to PErl 6.

The bundled Syck library has been updated to 0.55; the parser still works, and an emitter to serialise Pugs datatypes into YAML is planned.

iblech implemented two Roles for Net::IRC: Net::IRC::JoinOnInvite and Net::IRC::SeenExt.

After some wrangling with Haskell's type system, chromatic implemented $?CLASS and $?PACKAGE.

scook0 tweaked munge_haddock.pl so it also documents private functions, instead of just exported functions from modules.

putter, mugwump and Stevan continued their work on MetaModel. Stevan wrote a MetaModel compiler realises the meta-objects into real, Perl6-level Pugs objects, thereby effectively extending the OO system in itself. Amazing!

The atan() function was broken -- it was lacking an unary form, and the binary form was not adequately tested. putter fixed both issues.

mugwump added even more Unicode operators to Set.pm, and switched the implementation to use junctions internally.

Sorry for the brevity (and omissions) -- really need to sleep now. Ciao!

Day 107: Inline::Pugs! Infix operator!

An one-hour hack of mine proved fruitful. Below is a Perl 5 script, calling into Perl 6 functions:

#!/usr/bin/perl
use Inline Pugs => '
    sub postfix:<!> { [*] 1..$_ }
    sub sum_factorial { [+] 0..$_! }
';
print sum_factorial(3); # 21

The implementation is in the Pugs tree as lib/Inline/Pugs.pm; you wil need Inline.pm from CPAN to run the example above.

Another big news is that iblech hacked in user-defined infix operators. He started a fp.pm to showcase all the APLish things we can do with infix Unicode OPs. But my favourite sickitude is this faked list comprehension:

# This prints "3 9 15 21 27"
say [ {$_ * 3} | $_ <- [1 .. 10],:{ $_ % 2 } ]

# ...and here are the magic bits...
sub infix:«|» ($x, $y) { $x }
sub infix:«,:» ($x, &y) { [grep &y, $x] }
sub infix:«<-» (&x, @y) { map &x, @y }

mugwump and iblech applied this to Set.pm, which overloads various ASCII operators, as well as the ∩, ∪ and ∋ Unicode operators.

Seeing how PA02 has been delayed (again), nothingmuch interviewed me for a couple hours about Pugs interals, so he can start writing it. We covered Parser, Eval, ITypes and some Object core today -- more to follow later!

iblech also hacked in preliminary support for auto-generating [...] (reduce metaoperators); support for »...« (hyperoperators) should be coming soon as well.

putter reported that external PGE's match fails when the string to match contain a newline; it turns out to be a problem involving Parrot's line buffering. I fixed it using a hand-rolled escape scheme; however, I learned from matt in #parrot that stdin."setbuf"(0) will probably also fix it.

Corion reported that Win32's system($cmd, @args) quoting had similar problems with Perl 5; he committed some basic test for it and starts thinking of a better plan to fix it.

bsmith discovered a pugsbug that parses (1) { 2 } as (1).{2}, and wrote tests for it.

Stevan and mugwump continued MetaModel work, adding findMethod, invokeMethod, isPropertySupported and various other features. Most of them even comes with tests!

ninereasons fiddled with motd.p6 to generate a more sentence-like fragment, and tidied up its code.

theorbtwo committing another 100ish lines of changes, adding signatures and Haddocks to many Pugs internal modules.

putter did tons of work on the Rules tests imported from Perl6::Rules, cleaning up obsolete syntax and ensure that things pass both for external and embedded Parrot. Lots of bugs were shaken out and fixed.

I think that's all for today. See you tomorrow!

Day 106: Apache::RequestRec for Pugs!

Thanks to the jhorwitz's hard work, this now works with mod_parrot:

module PugsHandler;

sub _handler($r) {
    $r.puts("Hello world!");
    return 0;
}

Here $r is a Apache::RequestRec object; the entire handler is compiled to Parrot bytecode, loaded and executed in memory by mod_parrot, exactly like what mod_perl does. This means we will see something like this very soon:

SetHandler parrot-code
ParrotLanguage Pugs
ParrotResponseHandler ModPugs::Registry
Options +ExecCGI

clkao added tests for symbolic operators, and I implemented them within 24 hours. To wit:

sub prefix:<Σ> (@x) { [+] *@x }
sub postfix:<!> ($x) { [*] 1..$x }
say Σ [1..5!] # 7260

Note the use of the reduce metaoperator [...] above: [+] means sum, and [*] means product.

I finally finished reading Why's poignant guide to Ruby today. I'm grateful to Why's kind words in his Autrijus Raising Perl6 as a Real Puppy Should blog entry; I posted a comment there to look for a champion for the Cardinal (Ruby on Parrot) project, as I'd love to see it joining the ongoing collaboration among Pyrate(Python), ParTcl(Tcl), Pugs(Perl6), Ponie(Perl5) and other Parrot languages -- lately irc.perl.org #parrot has become a quite happening place!

The quickref project is building up steam from Juerd, kolibre and iblech: we have quickref/data, quickref/oo, quickref/op and quickref/var now.

With adehohum's helpful debugging, named subrule capturing now works correctly in Pugs/PGE:

rule fishy { (.*)shark };
"whaleshark" ~~ m/<fishy>/;
say $<fishy>[0];    # "whale"

Stevan has been reading a lot about Smalltalk and metaclass theories; he applied them to Perl::MetaModel, delivering many magical results with small amounts of code. After all, what's a magician but a practicing theorist? :-)

Darren added full tests for Locale::KeyedText, but noted that the lack of class methods, compile-time import with use lib '/path', $obj.meta and is constant is holding the tests from passing. I'll see what I can do for them in the 6.2.4 release...

luqui pointed out that we should use Manhattan distance (sum of inheritance deltas), instead of leftmost tiebreaking, to dispatch MMD; it's now implemented. However, I'm very surprised to learn that there can be multiple levels of invocants: multi sub foo ($x: $y: $z: $w) {}; now a nontrivial amount of Pugs internals needs to change for this underdocumented specification. This issue is raised on p6l, along with some type coercion issues.

scook0 changed Haddock to use the more manageable {- ... -} block inline style, then added more function signature declarations.

Corion, iblech, putter, mugwump and masak performed more helpful gnoming on various unit tests and documentations.

luqui hacked Makefile.PL a bit to allow user-specified hsc2hs executable via $ENV{'HSC2HS'}.

nothingmuch checked in his helpful util/smoke_loop.sh script, a complete smoke test loop to automatically build parrot, p6bible, haddock and pugs itself. He also updated the smoke graph to use inline CSS, which requires the latest version of Test::TAP::HTMLMatrix.

iblech added a splash screen to the Pugs/Parrot live CD, hacked in »~« support, and added a test for the bug that prevents bare blocks from containing $_.

See you tomorrow!

Day 105: More OO and more Parrot

I spent almost all day chasing weird bugs after weird bugs for $work, that involves Perl 5.005, DB2, and Windows 2003 -- you really don't want to know the details. So, not much time left for Pugs; however the lambdacamels carried on as usual with amazing velocity.

Stevan and mugwump continued hacking on Perl 6's metamodel document, to a point that I can simply use it as specification for Pugs's OO framework. This is making my life too easy -- the specs and tests are written, so I can be a happy implementation monkey. :-)

Stevan also added a HOWTO on creating your own object model, explaining how to put all these abstractions to use, e.g. creating a thread-safe base class.

The last version of S29 from Rod Adams has been committed to docs/AES/ alongside other "community drafts" of Synopses and Apocalypses. I'm delighted that Aaron (ajs) will carry on with Rod's helpful coodination effort, and Patrick will act as "Cabal bridge" to merge them back to @Larry's official design. *applause*

Darren updated Locale::KeyedText to cleanup workarounds for yesterday's Pugs -- because they work today now. I'm sure tomorrow he will find more workarounds to obsolete.

eric256 updated wizards.p6 to exercise more on the new OO inheritance support, as part of his planning for a grand future. Hmm...

chromatic went into full gear and covered Test::Builder with many many tests. Amazingly, many of them actually passes. This, too, has made my life much easier.

jhorwitz continued to work on Parrot codegen, this time adding support for method invocations, and .namespace generation for modules, packages and classes. Once the rest of OO metamodel is in, we can start seriously align our model with Parrot's class support and see what's missing from either sides.

On more Parrot news, it seems that tewk is rekindling Pyrate, the Python-on-Parrot project. I sent him an invitation to the openfoundry system for free hosting of svn (and mailing list, RT, etc); we discussed briefly about boxed types and how to proceed from here. Now we have champions for Tcl, Python and Perl, I wonder if the Cardinal (Ruby on Python) project will somehow revive...

Leo mentioned he's been reading a lot of STM papers, and he thinks Parrot should support it, too. I'm very excited, as I think efficient support for composable concurrency in SMP settings is a distinct advantage for a VM -- and may even become a neccessity in the near future.

putter reports that with the latest GHC snapshot, x86_64 users can finally build Pugs without problems. Let's hope GHC 6.4.1 will be released soon.

iblech noticed the capitalize() function on S29, wrote test for it, then implemented it right away, so we can easily turn pUGS is cOOl! into the less-l33t Pugs Is Cool! now.

When adding tests for rand(), iblech discovered that foo() -1 would parse as foo(){'3'} - 1, because function applications was globbing trailing spaces. It's now fixed.

putter found that not 4,3,2,1 evaluated to 0,3,2,1; that's a bug, because not is supposed to be list operator with low precedence. Perl 5 had it as 4,3,2,0, which is equally bizzare, so I asked p6l for clarification, and Larry responded with some rulings.

A long-standing (that's three days) OO bug has been closed: use Tree; Tree.new is no longer parsefail. Hence all the ::Tree.new workarounds can be eliminated.

iblech added various tests for $?SELF, $?CLASS, $?ROLE, submethods, and many more. He also ported Net::IRC to Perl 6 OO, which would be fully functional except for the missing submethod BUILD support. Warte nur, balde...

iblech also tweaked the Pugs live CD a bit, and added a ?check command to svnbot.p6 to force rechecking of new revisions. It is also worth mentioning that clkao's hack to make svnbot announce committer++ for each line of commit log has been very well received -- and detailed change logs are really helpful too.

Darren fixed Test.pm's style of $ALL_UPPERCASE for non-constant global variables.

masak noted that die "123\n" still incorrectly prints out the stack trace, then added a test for it.

scook0 added more Haddocks for Monads.hs, then added a test for next()'s misbehaviour in loop() blocks.

Corion unTODOed succeeding tests, and noted that map with multi-statement blocks now partially works, but still re-uses the pad for each loop.

Whew. That was a lot. See you tomorrow!

Day 104: ./juerd('rocks!')

Yesterday's punctuation dilemma was fixed by Juerd's nice proposal, namely using ./method as a shorthand for $?SELF.method. Larry calls it terminally cute, and I promptly implemented it in Pugs. Juerd++!

Lots of OO works were done today after I got my laptop back:

• Inheritance in the form of class Foo is Bar { ... }
• Private method definition with method :foo { ... }
• Private method invocation with .:method
• Private attributes now generates private accessor methods: has $:attr
• Method interpolation in strings no longer eats up trailing whitespace, e.g. the space in "$obj.hello() World".
• Parameterised return types is now parsed: method foo returns Hash of Int. I need to ask about how to define such parameterised classes some day...
• Dereferencing: @{...} and %$foo etc.
• Finally, I tweaked both wizards.p6 and Locale::KeyedText to use the new syntax.

Much thanks to Stevan, eric256, Darren and chromatic for their early adoption of Pugs OO. I'm happy to see that Locale::KeyedText, the first non-core Perl 5 module ported to Perl 6, is back to ext/ as it works now. Was it really only two months ago? :-)

In other news, in non-embedded mode (such as on Win32, by neccessity), Pugs 6.2.3 spawns one Parrot process for each Perl 6 rule match, which is horribly slow. I've written some more PIR so only one Parrot process is kept now.

Juerd helpfully informed me that the use of infix:<!> to construct none() junctions has been denied, so it's gone from Pugs.

eric256 p6ified life.p6 a bit, but notes that it's still slow. Well, that's what the Prarot compilation backend is for. Speak of which...

...Much to my delight, jhorwitz started hacking Pugs's Parrot codegen in earnest, in order to get mod_pugs working in mod_parrot. Hrm, should we call Pugs/Parrot people lambdabirds? :-)

scook0 and bsb diligently added more Haddock to Prim, Run and Monads modules. skew begins looking into the type tree implementation in Context.hs; hopefully we'll making it a proper directed graph some day to facilitate faster queries.

Stevan started writing tests for Test::Builder, which is dangerously close to fully functional now. He also updated meta_meta_classes.pod with a snippet of discussion between gaal and him, to explain the raison d'être of MetaMetaModels.

The ever-inventive iblech implemented an IRC log to HTML converter in Perl 6. It's not huge -- 300ish lines -- but neatly shows how real world Perl 6 scripts looks like.

Oh, and I submitted two talks to Euro OSCON today: Perl 6 in the Real World, and Learning Haskell. I think I may be a bit overboard on the description for the latter:

What's faster than C++, more concise than Perl, more regular than Python, more flexible than Ruby, more typeful than C#, more robust than Java, and has absolutely nothing in common with PHP? It's Haskell!

Tired of writing unit tests to cover corner cases? Let the computer write them for you with QuickCheck. Find regex-based parsing unmaintainable? Learn how to write a complete parser for Perl 6's grammar in 15 minutes with Parsec. Stuck in deadlocks and race conditions? STM solves all your concurrency woes. XS and SWIG gives you headaches? FFI lets you embed C code quickly and safely.

Haskell is an emerging general-purpose functional language, with unique features that enables extremely rapid development of bug-free, concise and maintainable code. This talk shows how to apply Haskell to day-to-day tasks, tips for integrating it with other languages, and secrets for boosting your productivity by an order of magnitude.

I blame the poignant why the lucky stiff for the influence. :-)

Day 103: Mere punctuations.

My laptop's AC jack burned up last night, so it's in for a partial transplant now; considering how the keyboard and cd-rom are also quite kaputt, hopefully it will be back tomorrow as promised by the repair people. :-/

Following yesterday's syntax change: it seems that ^method was not, after all, an accepted or welcomed consensus for calling methods on the current invocant. So it's gone from Pugs; use $?SELF.method or declare method foo ($self: $arg) explicitly, as explained by Larry.

There have been some discussions on #perl6:

<autrijus> the dot in $.attr is unfortunate
<PerlJam> autrijus: indeed
<eric256__> yea i'm not sure i like $. being so much different than .

However, I think it's time to move on:

<autrijus> but, anyway. as interesting as punctuations are, I don't think it's wise to dwell on them too long... I got my answer and that is $?SELF or explicit inv for now.
<autrijus> I'd much rather leaving @Larry more time to figure out the missing Tier-1 synopses.
<PerlJam> autrijus++ yep. you have the wisdom of it. :)

In other p6l news, Damian posted an interesting list of use-cases for the [...] reduce metaoperator. I noticed this neat example (slightly paraphrased):

if ([<] @numbers) {
    say "All numbers are monotonic!"
}

So I asked about whether [...] preserves the associativity of the operator inside. Larry confirmed with a punny explanation, comparing the metaoperator with radio:

Yes. It's as if there is a long cat, only without the cat.

The usual rapid flow of commits and ++s continued today:

• The $obj.id method is implemented to return an unique ID for each object.
• foo($obj) was parsed incorrectly as foo(: $obj); it is foo($obj :) now.
• Stevan made Perl::MetaModel use real Perl 6 OO now. When I get my laptop back and implement the Haskell-side metametamodel, we'll have a nicely reflective strange loop to play with.
• bsb added Haddock to our messy-by-neccessity command line argument parser.
• gaal noticed that <<$var>> was suddenly returning match objects that loops forever, due to the internal implemention's use of split. I kluged a :stringify rule adverb to deal with this issue.
• iblech added more documentations for Set.pm and Net::IRC, then went ahead to use Set objects to maintain the list of currently joined channels.
• masak and iblech cleaned up meta_meta_classes.pod a bit more.
• Juerd started quickref/data for data structure syntax.
• Corion cleaned up many OO tests, and moved even more working pugsbugs tests to where they really belong.
• adehohum found some bugs with lexical scopes inside map, and wrote tests for it. He also found new ways to make PGE segfault -- I think I'll move all P6Rules tests en masse back to the parrot tree where PGE lives.
• eric256 and iblech worked on tests for the reduce metaoperator.
• Thanks to pjm, I added a notice to README to say OS X 10.4 (Tiger) users need to gcc_select 3.3 for compiling Pugs with GHC 6.4.

Day 102: Meta-Meta-Hackings.

With Pugs 6.2.3 out of door, many lambdacamels turned their attention to the newly introduced OO implementation, committing lots of examples, documentations and tests:

• Stevan neatly summarised the ongoing MetaModel work, a basis for the future (or imminent?) Perl6-compiler-in-Perl6 effort.
• eric256, our new committer, implemented a RPG game (also see his Perlmonks writeup), which exercised many OO features and bugs.
• ...those bugs, in turn, were made into unit tests by eric256. Yay!
• Juerd started the quickref project to produce short summaries of Perl 6 syntax. The operator part is already quite complete; volunteers welcome!
• mugwump and Stevan continued to work on Set.pm and Tree.pm, the first two Perl 6 OO modules.
• Stevan noted that many of t/oo/ tests actually passes; iblech and he then proceeded to write some more.

These activities prompted various internal changes:

• $.typed_attribute.method is now handled by MMD.
• .method changed to mean $_.method; to call method on the current invocant, use ^method instead.
• do { ... } block literal is now supported.
• submethod is parsed.
• Qualified type literals are now parsed correctly, e.g. in sub Baz returns Foo::Bar.

On the bot-writing front: right after 6.2.3's release, metaperl invited #perl6 to play hangman cooperatively, with him relaying between the channel and hangman.p6. I noted that a hangman bot is more suited for this task; minutes later, iblech produced hangmanbot.p6, and we played a couple round of games. Lots of fun!

Also as a result of hangmanbot.p6, people found the NOTICE messages used by bots annoying, so iblech turned them into regular PRIVMSGs. Hopefully my checkins won't disrupt people's sleep again...

<Stevan> horray,.. openfoundry is back
<wilx> ~_~
<wilx> I forgot to turn off my speakers befire I went to sleep and my mIRC beeps on notice.
<wilx> It woke me up :/

clkao finally got the committer bit and wrote his first lines of Perl 6 code, to change the svnbot's announcement from committer -- to committer++. We also discussed various approaches to port svk to Perl 6.

On the perl6-language front, after some discussion with pmichaud, we suggested the $0 (that's $1 in Perl 5) produced in '123' ~~ /(\d+)/ should numify to 123, instead of the absurdly surprisingly 1 which tripped iblech, Stevan and me. Fortunately, sanity prevailed; Larry and Damian both OK'ed the suggestion, and it's been implemnted in both PGE and Pugs.

Also, per Larry's explanation, split with capturing rules now inserts the match objects of submatches into the resulting list, instead of their stringified forms.

Other commits of note:

• bsmith added more export lists to .hs code, making refactoring easier.
• bsmith, Forth (another new committer!) and I worked on getting pugs_version.h correctly generated from svk checkouts.
• corion helpfully moved away passing tests from t/pugsbugs/ to other subdirectories where they belong.
• ninereasons purged the remnants of old-style force_todo into per-test :todo<bug> forms.
• jhorwitz and I made $! into the exit value after an unsuccessful system() that returns false.
• iblech cleaned up Net::IRC a bit, adding even more commands to it.
• gaal made the tests more robust when running in parallel, by using nonces as temporary file names and cleaning them up.
• iblech noted with delight that s/./{ state $var; ++$var }/ works perfectly, and added a test for it.
• scook0 inquired me about the design for various internal data types, then added them to the API documentation.

Last, but not the least, I've finally committed some non-broken C code into the Parrot tree! I separated the bogus mix of ASCII and ISO-8859-1, and made ASCII-to-Unicode transcoding an O(1) operation, as it should be. Following on my suggestion, Leo proceeded to implement utf8:unicode:"string" literals that plays well with the existing unescape code.

I also made ASCII and Unicode's validate detect noncharacters correctly, so there is less chance of accidental double-encoding now. The mistake of Perl 5's latin1-biased Unicode model must not be repeated in the new era! ;-)

Day 101: Pugs 6.2.3 released!

On behalf of the Pugs team, I am delighted to announce the release of Pugs 6.2.3, with Parrot embedding, Perl 6 Rules support (via PGE), and an initial sketch of OO system. Multi-thread programming with async/kill/join/detach is now supported as well.

Also of note are many new, working modules under ext/, some using the newly supported OO system, some using an inside-out OO system based on closures.

Pugs is available from a nearby CPAN mirror, or from pugscode.org:

Perl6-Pugs-6.2.3.tar.gz
SIZE = 894640
SHA1 = 16599281a8a103d13e4f0041ccba06bddff28f83

As Pugs now requires Parrot 0.2.0 or later for Rules support, you may wish to install Parrot first:

parrot-0.2.0.tar.gz
SIZE = 2696634
SHA1 = da4231fda3b7fcb842a886bef3d86d477ecc34e6

Thank to all the lambdacamels for flying with Pugs! :-)

Enjoy,
/Autrijus/

Changes for 6.2.3 - May 12, 2005

Pugs Internals

• Pugs can now embed Parrot or use an external parrot executable
  • Under embedded mode, Pugs is a registered Parrot compiler
  • eval_parrot and require_parrot builtins for running PIR code
  • pugs -BParrot can compile Perl 6 program to PIR and run it in-memory
• Perl 6 Rules support via Parrot/PGE:
  • Named rules and subrule support
  • The former $0 (entire match) is now $<>
  • $0 is now the same as ~$/[0], i.e. the same as Perl 5's $1
  • .from, .to, .matches
  • //, rx//, m//, rule{}
  • s/// and // in statement level operates on $_
• Basic Object support:
  • Accessors generated for public attributes
  • Identity operator: =:=
  • Method chaining: $foo.bar().baz()
  • Method invocants: method foo ($self: $x) and topicalized as $_
  • Public and private attributes, as well as has $.attr is rw
  • $obj ~~ Class support
  • $obj.clone() support
  • class Foo {} works (no inheritance yet)
• Experimental eval_yaml() support to parse YAML streams
• Experimental support for prefix reduce metaoperator [+]
• Hyper operators now works on arrays too
• Improved .perl() format for array, hash and pair objects
• Much faster random access to arrays; it's now O(1) instead of O(n)
• Much improved MMD support
• New is lazy trait for parameters
• Refactoring of large Haskell modules to improve compilation speed
• Support for building a profiled Pugs
• Undef in grouped lhs: my ($x, undef, $y) = 1..3; is now legal
• $thread.kill, $thread.detach, $thread.join
• %hash.pick, @array.pick and (list).pick
• reduce primitive
• state $var implemented
• system(Str: List) and exec(Str: List) on Unix platforms

Bundled Modules

• All modules have their own ChangeLog now
• Algorithm::TokenBucket, with closure objects
• Config::Tiny, with closure objects
• Kwid::Event::Parser, with procedures
• Net::IRC, with closure objects
• Perl::MetaModel, prototype of Perl 6 OO meta-model in Perl 6
• Pod::Stream::Parser renamed to Pod::Event::Parser and added more functionality
• Set, with Perl 6 objects
• Test::Builder, with Perl 6 objects (parses, but does not work yet)
• Tree::Simple, with closure objects

Tests, Examples and Documentations

• Many new test and several tests refactored, we now have 4921 tests
• Documentation for hangman.p6 added in examples/games/hangman.pod
• New "Monads in Perl 6" example in examples/functional/monads.p6
• Script to generate a Pugs Live CD in util/livecd
• Several IRC bots added to examples/network including svnbot and logbot
• TODO tests now use :todo<reason> for better reporting
• The first Perl 6 poem in examples/poetry/

Bug Fixes

• Logical short-circuiting operators no longer flattens references
• Prohibit Array and Hash dereference on plain values
• Slurpy context no longer flattens
• Stringifying IO handles is no longer fatal
• $*PID now works on Win32
• %*ENV now completely works on Win32
• (a => 3+4) is now parsed as (a => (3+4)), not (a => 3)+4
• any().pick no longer dies
• my @x = [1]; @x[0][0] = 2 should now work
• next in nested for {} blocks no longer escapes the outer loop
• to => 123 parses again; arrow pairs now always trumps unary functions
• {} in P5 rules is no longer closure interpolation

Day 100: OO support landed!

Breaking news -- This now works in Pugs:

class Point {
    has $.x;
    has $.y;
    method show () { say "Coordinate: ($.x, $.y)" }
    method set ($x, $y) { $.x = $x; $.y = $y }
}

my $pt = Point.new(:x(10), :y(20));
$pt.show;   # Coordinate: (10, 20)

my $pt2 = $pt.clone;
$pt.set(30, 40);
$pt.show;   # Coordinate: (30, 40)
$pt2.show;  # Coordinate: (10, 20)

say(($pt ~~ Point).perl);   # bool:true
say(($pt ~~ Hash).perl);    # bool::false

Read-write accessors, alternate invocant names (e.g. method foo($self:)), automatic topicalizing etc all works, too.

Juerd reported that the slurpy context was implicitly flattening its arguments; that is clearly a Bad Thing. It's now fixed.

Larry decided to change $0 to mean the first captured match, to agree with $/[0], and avoiding massive off-by-one errors in the future. It's now implemented in Pugs -- instantly breaking lots of tests and example code -- but iblech heroically repaired them within minutes.

Day 99: Full named rules!

This now works in Pugs:

    rule name { Larry | Matz | Guido }
    rule project { Perl | Ruby | Python }
    rule description { <name> \s does \s <project> }

    'Larry does Perl' ~~ /<description>/;   # true
    'Larry does Java' ~~ /<description>/;   # false

Also supported are s///, m//, //, rx//, anonymous rule{} and split.

After that, I cleaned up some 800 tests for Perl 6 rules, ran Pugs through it, discovering some segfaults in PGE along the way -- and pmichaud has fixed every one of them within five minutes. Much kudos!

Stevan continues to do huge amounts of work on Perl::MetaModel, charting a comprehensive support for Perl 6 OO reflection.

Net::IRC kept gaining new features. I have this feeling that a major Perl 6 application may appear as a IRC bot...

During bot-writing, iblech discovered that to => 3 was not parsing correctly; it's now fixed.

bsmith did lots of refactoring to split big .hs files into smaller chunks, greatly reducing compilation time and cognitive stress.

Corion made %*ENV completely work on Win32, then continues to grab even more Win32 API calls into Pugs.

Oh, and the reduce primitive was implemented, too.

There's more to summarise, but I need to (again) punt. :)