Thursday December 07, 2006
Perl 6 Design Meeting Notes for 06 December 2006
The Perl 6 Design team met via phone on 06 December 2006. Larry, Allison, Patrick, Jesse, Nicholas, and chromatic attended. These are the notes.
- checked in the IO PDD
- need to post a message about that
- I have some questions
- no one will likely read through the diff
- typing the list of platform requirements to add to PDD 0 or PDD 1
- I'll check that in later today
- anything interesting going on with the external folks using Parrot?
- Ruby and Python?
- the Pythonish people stalled out on lack of time
- there is no external Ruby implementation going now
- tewk's is in tree
- the external Cardinal died due to lack of time
- I haven't looked at Pyrate very much
- is it worth evaluating it in terms of the new compiler toolkit?
- I think that's the way to go
- I think it stalled under the weight of its infrastructure
- things are going quite well
- last Friday I spent the day coding
- the compiler now handles quoting in all sorts of forms
- double and single angle brackets, interpolators, embedded method calls, etc
- and for the forseeable future!
- how extractable is that feature?
- can you make that available to other compilers?
- parsing that doesn't seem to lend itself to bottom-up or top-down parsing
- the trick is that I wrote my own quote term parser in PIR
- it's essentially the same thing that I do for PGE's Text::Bracketed
- it was much easier to do that in PIR than in anything else
- are you grabbing the strings by delimited items?
- you can't even do that
- I tokenize as I go with a special tokenizer
- I know when I start a quoted string and I know the adverbs in effect
- then I go
- I know what the characters mean with the adverbs in effect
- just builds up the data structure as it goes
- when your tokenizer determines that it has completed, it hands back to the parser?
- a match object with all of the pieces that it found
- it looks like it came out of a rule
- we just didn't use Perl 6 rules to get there
- long-term, we probably want to make that custom ability available to other compilers
- a lot of languages will need something like that
- I think the differences between the languages are significant enough that people will end up cargo-culting it
- it's not that long a routine
- if someone wants to come up with an API for it though, great!
- it shows off all of the things you might want to do inside of that
- I don't have
qw() defined, but I just have to add the tokens for it
- playing around more with HLL compiler object
- reviewing parts of the Pugs test suite
- checked in some changes to the range operator yesterday
- now I need
for loops and
- have an implementation, but want to clean it up
try blocks too
- are they near the top of your list?
- they are
- everything I've done is getting those to work
- also looking at class name mappings
- just have to figure out where I want to store them
- the infrastructure is all in place
- once I have the sanity tests passing, it opens up a whole realm of things
- people can jump in and add things
- mostly just working
- continue to work out the relationships of bags, sets, and hashes
- trying to keep the smart match table simplified
- also noticed an extra set of braces every time I use a gather
- decided to make it use the same syntax as do
- now expects any statement afterwards
- possibly that doesn't make sense, but we'll see
- you can still use a block if you want
- seemed like a notational convenience I kept wanting
- after I did that three times, I put it in
- hand-translated my work program back to Perl 5 to get it running faster
- I look forward to have that running on a fast engine
- how much more verbose and painful did it end up?
- about twice as long
- I cheated a little bit on line count, but....
- were any of the 6 on 5 alternatives workable?
- I didn't try
- I considered that alternative, but I can't tell you why exactly I didn't try it
- the wrong computer in the wrong place at the wrong time, I guess
- maybe I felt like I needed punishment for my past sins
- physically trying to take it easy over the next couple of months
- setting up a bug day
- I'll spread the word further
- have had positive feedback so far
- saw a Perl 6 (when released) job offer in Oxford
- at least someone wants it released
- I could use some guidance or suggestions on how to deal with lazy lists in Parrot
- what's the trick to doing lazy lists in Parrot?
- iterators and generators with a defined interface
- that's basically it
- Higher Order Perl is good place to start
- SICP has value too
- basically an abstraction
- look if it's there, then generate it
- might need some caching
- an iterator just iterates and throws it away
- looking at the for loop
- when I have
for and LIST or
for and ITERATOR
- how synonymous are LIST and ITERATOR?
- depends on whether you consider that for operating on a pre-generated list iterates over an iterator
- or a list of lists
- if you venture into terra incognita if you have to call a generator on the next list
- the Synopses are relatively silent on accessing iterators
- basically any list context expects to receive a lazy list
- depends on what it's bound to and how it reads out what it's interested in
- but it's lazy
- it's not something I need right away
- the first few implementations will likely use eager lists to get the tests running
- just want to get things running first
- Pugs won't help either
- Haskell gives that implementation for free
- there are some iterators that want to be eager
- generate the next 50 items
- is there an interface that they expect to have?
- the Apocalypses handwaved about a
.specs method for example
- mostly we're making it up as we go along
- if we have to bend the specs to be more rational, we'll have more rational specs
- are the specs waiting for us to do an implementation we can react to?
- lots of places in the specs where I have an idea about the abstract interface
- waiting for various implementations to negotiate other things, such as the introspection interface
- it'll shake out
- be careful of the semi-predicate problem
- often easier to have a method on the iterator that tells you if you've exhausted it
- don't want to run into the
eof() problem again
- sometimes you have to read it to know if there's something remaining
- you can't always solve that for IO, especially network IO