Before putting PIL evaluator to action, I thought I'd take some time off to read relevant papers. But as I chase the references, everything seems to be related to each other, and before long I find myself reading fascinating things that may not have any obvious connections with PIL. ;-)
Stevan asked me to put links to what I've read. Below is a quite incomplete list, in roughly chronological order.
I started off with the two QuickCheck papers. I had a passing understanding of specification-based testing, mostly via Test::LectroTest,
but the papers highlighted many aspects I've never thunk of. Grokking the coarbitary construct is a lot of fun; it is fascinating how QuickCheck can generate arbitary functions randomly, purely based on its type signature.
From QuickCheck I've moved to Scrap your boilerplate with class, the third paper in the SYB series, which provides a nice way to do generic programming in Haskell. In the design pattern world, the generic programming strategies would be known as visitor, composite and other related patterns; in the SYB papers, similar ideas are expressed in a very concise fashion, and the notion of type class variables feels very natural indeed.
SYB's predeccessor, Strafunski, proved to be rather hard to grok in one sitting. I got sidetracked to its SDF component, which describes a nice way to do scannerless parsing -- that is, parsing directly from character level, without a tokenizer. Pugs uses this approach too, and I confess I've never felt the use for a tokenizer. But perhaps I'm spoiled by fast computers, perl5's capable regex engine, and the even more capable Parsec. Still, SGLR/SDF is far easier to reason about than parser combinators or regex with embedded code, and if its claim of superior performance is true, the it's definitely worth more investigation.
From there I moved to the Lambda cube, and the Calculus of constructions (CoC). First-class types and bindings is one of Perl 6's shining new features; the design team recognizes its importance and uses, but very little is understood in how it works in the implementation level, and how it interacts with constraint-based subtyping.
As CoC allows no subtypes, I turned to Scala, an advanced multi-pradigmic language featuring not only subtyping and trait-based mixins, but also generics, views, macros and inferencing, which are all underspecified parts of Perl 6. I have just begun reading the Scala papers, but the first one (the vObj paper) is already extremely enlightening -- especially because it contains detailed comparison with both OO-style languages like Java, as well as functional-style languages in the ML family.
I have also looked at PyPy's parser and evaluator, and skimmed through many other papers in several detours, but the above are the primary ones. The lyf so short, the craft so longe to lerne...
