Lambda the Ultimate

Which basically boils down to the notion that it's fine for Perl to have a type system as long as it's optional. It's just another area where Perl 6 will try to have its cake and eat it too."

It's about time, wouldn't you say?

Every macro is associated (implicitly or explicitly) with a particular grammar rule that parses and reduces the arguments to the macro. The formal parameters of a macro are special in that they must be derived somehow from the results of that associated grammar rule. We treat macros as if they were methods on the parse object returned by the grammar rule, so the first argument is passed as if it were an invocant, and it is always bound to the current parse tree object, known as $0 in Apocalypse 5."

var foo = bar.curry({goo : "hello world"});

If goo happens to be the first argument you can also write:

var foo = bar.curry("hello world");

and if it happens to be the last argument:

var foo = bar.curry({-1 : "hello world"});

Binding to the second argument:

var foo = bar.curry({2 : "hello world"});

Or, you can use the fact that curry() also accepts an array as the list of values to bind to so you write:

var foo = bar.curry([,"hello world"]);

The first array element in this case is empty so its not bound to.

Binding to several arguments can be done as:

var foo = bar.curry("hello").curry("world");

or simply:

var foo = bar.curry("hello", "world");

In addition we also provide the using() method which is similar to curry() but handles binding of functions differently. If bar and goo are functions:

var foo = bar.curry(goo);

binds a reference to the function goo to the first argument. OTOH:

var foo = bar.using(goo);

binds an invocation of the function goo to this first argument. That is, whenever foo is called, goo is also called automatically and its return value is assigned to bar's first argument.

Finally writing:

var foo = bar.andThen(goo);

is equivalent to writing:

var foo = goo.using(bar);

First bar is activated and then its return value is passed along to go.

The first thing that occurs to me is that Larry could acheive a boost in performance and cut down on his development time by years by simply providing a translation layer from Perl 6 grammar to a language that has mature compilers which implement nearly all of the functionality desired in a single package.

I say this because the RFI's taken together create a feature-set almost resembling that of Common Lisp. No, I'm not meaning to troll, but this is a very ambitious set of goals.

I agree. What I am most interested in is Larry's design approach (backward compatability vs. new features) and his unique approach to syntax in general and syntactic sugar in particular.

The integration of the new features into Perl5, which is a mature language with a large base of users is the important thing here. The language features themselves are for the most part not original.

I find it impossible to read to the end of any of Larry Wall's writing, so I'll just note I find the specification mind-bogglingly complex. I also don't think the complexity is necessary as other languages offer the same features without the syntactic obfuscation.

More interesting to me is the way Larry Wall writes:

Third, it allows the S&M folks to inflict strongly typed compile-time semantics on each other. (Which is fine, as long as they don't inflict those semantics on the rest of us.)

The same point could be made without the value judgement but stating the point in this was is implicitly defining the values of the Perl community, and stating who is in and who is out. I conjecture that this style of writing helps to unify the Perl community by enforcing their shared values. I wonder if this is important in the development of an open-source language? Having a cause to unite behind is certainly a good way to gather converts.

No other language comes to mind.

(From http://caml.inria.fr/camlp4/manual/manual005.html)

Syntax of a position

A position can be:


    * FIRST: The extension is inserted at the beginning of the precedence levels.
    * LAST: The extension is inserted as the end of the precedence levels.
    * BEFORE label: The extension is inserted before the precedence level so labelled.
    * AFTER label: The extension is inserted after the precedence level so labelled.
    * LEVEL label: The extension is inserted at the precedence level so labelled. 


Only the case LEVEL extends already existing levels: the other cases create new levels.

    $id = $subref.wrap({
        # preprocessing here
        call;
        # postprocessing here
    }

The call built-in knows how to call the inner function that this function is wrapped around."