use Perl

(Sorry, forgot to post these last week)

Luke:
        - until last Wednesday, I worked on PGE in Perl 6
        - then I worked on something completely unrelated
        - PGE in Perl 6 now, barring the operator precedence parser, does
            everything that the Parrot one does
        - except for parsing rules
        - but Audrey is doing that

c:
        - does it produce match objects like PGE does?

Luke:
        - yes
        - last week I thought about things
        - XQuery, tree matching
        - pondering a data comprehension module for Perl 5
        - whatever can make processing big, complex data structures quick and easy
        - working with Audrey on context and coercion
        - we have some disagreements about how that works
        - mostly we're on the same page
        - wrote a document describing pure MMD scheme
        - including return type dispatch
        - related to context
        - those are in the Pugs repository
        - I'll hack on them and then pass them along

Larry:
        - did about 18 refactorings of the Perl 5 to Perl 5 translator
        - ends up with a more adequately typed AST

Luke:
        - typed how?

Larry:
        - I'm not quite sure what I mean either
        - a lot of the stuff internally to Perl is implicit
        - there's no name for a particular node in the tree
        - they happen accidentally
        - we rearrange kids somehow and change a few flags and it applies
            differently
        - trying to name everything, or at least get close
        - they're types in that sense
        - it's not yet well-typed in the sense that I've looked at those names
            and tried to figure out what's common between them
        - it's nothing like PIL
        - it's just trying to give a name to everything so we can have a hope at
            translating at some point
        - basically there are more node types currently than there are operator
            ppcodes in Perl 5
        - there's now a Statement, which doesn't really exist
        - there's an opcode for transitioning into a statement in Perl 5
        - but nothing really contains a statement
        - that's a lot of the refactoring work
        - make a more ordered tree
        - now, of all the tests in the core modules, it translates more than 99.5%
            correctly
        - I haven't tried CPAN; I'd have to download it
        - I also haven't bothered to try to hook this up to bleadperl
        - I can probably delegate that eventually
        - most of these refactorings come about due to thinking about what I need
            to translate to Perl 6
        - making sure that the information is there
        - haven't actually tried to translate anything yet
        - eventually I'll get up the courage to translate $foo[] to @foo[] and go
            from there
        - otherwise, thinking about what people say on the mailing lists
        - admittedly not being very responsive to that

Allison:
        - planning to take time off around Christmas to do development
        - but I had my wisdom teeth out
        - started working on expanding the Punie grammar again
        - made it into sexpr part of the original perly.y
        - ran into the traditional left recursion problem
        - decided to use PGE's operator precedence parser instead

Luke:
        - with regard to left recursion, there's a simple transform you can do
            with closures to turn right-recursion data structures into ones that
            look like left recursion

Allison:
        - rather than doing left recursion, I flipped around
        - broke it into two pieces
        - the first element, and the rest of the expression

Luke:
        - x [\+ x]* ?

Allison:
        - expression matches
        - expression = expression
        - expression = expression + expression
        - instead, say expression = term + rexpression

Luke:
        - that's my biggest complaint about Parse::RecDescent
        - it has a nice leftop which does that
        - but then you get back a flat structure of all the matches you want
        - I want a left recursive structure
        - it's easier to parse things that look left-recursive
        - you only have to handle two arguments, not N
        - left-recursion transform might be nice in grammars, if it's generic...

Allison:
        - for now, all I need in Perl 1 is operator precedence
        - looks pretty cool so far
        - I'll try to finish it off by the end of the day
        - it'd be nice to have comments in the syntax of the independent grammar,
            but...

Luke:
        - my friend the crazy C++ programmer is trying to learn a new language
        - I invited him to learn Perl 6
        - I'm going to try to teach him Perl 6 without any past knowledge of
            dynamic languages