An video compilations

p6apclps #105 Perl 6 Apocalypse
Mon, 01 Dec 2008 12:42:16 -0800 by h4ck3rm1k3

http://www.perlfound ation.org/perl6 - - use of this information.) Subroutine traits These are traits that are declared on the subroutine as a whole, not on any individual parameter. Internal traits The "signature", "returns", and "do" traits are internal traits containing, respectively, the type signature of the parameters, the type signature of the return value, and the body of the function. Saying: sub Num foo (int $one, Str *@many) { return +@many[$one] } is short for saying something like: sub foo is signature( sig(int $one, Str *@many) ) is returns( sig(Num) ) will do { return +@many[$one] } In fact, it's likely that the "do" trait handler has to set up all the linkage to pass parameters in and to trap "return" exceptions. Many of these pre-defined traits just map straight onto the container object's attribute methods of the same name. Underneath they're just accessors, but we use the trait notation in declarations for several reasons. For one thing, you can string a bunch of them together without repeating the original object, which might be anonymous in any event. It also gives us liberty behind the scenes to promote or demote various traits from mere properties to attributes of every object of a class. It's one of those levels of indirection computer scientists keep talking about... Going the other direction, it allows us to pretend that accessors are just another form of metadata when accessed as a trait. By the same token it allows us to transparently make our metadata active rather than passive, without rewriting our declarations. This seems useful. The basic rule of thumb is that you can use any of a container's "rw" methods as if it were a trait. For subroutine containers, the example above really turns into something like this: BEGIN { &foo.signature = sig(int $one, Str * @many); &foo.returns = sig(Num); &foo.do = { return +@many[$one] } } [Update: A12 goes as far as to turn all properties (including traits) into mixins, so all these traits really are accessor methods.] "is rw" This trait identifies lvalue subs or methods. See the section on lvalue subs below. "is parsed(*[rule]*)" This trait binds a macro to a grammar rule for parsing it. The grammar rule is invoked as soon as the initial keyword is seen and before anything else is parsed, so you can completely change the grammar on the fly. For example, the "sig()" function above might well invoke special parsing rules on its arguments, since what is inside is not an ordinary expression. In the absence of an explicit [is parsed] trait, a macro's arguments are parsed with whatever "macro" rule is in effect, by default the standard "Perl::macro". [Update: The default parse rule probably turns out to be dependent on the grammatical category of the macro. A prefix macro wants a list by default, while an infix macro just wants a scalar expression for the right argument. A term probably wants no argument at all. Macros for things like rule modifiers probably want to parse like trait verbs. On the other hand, an infix_circumfix_meta _ operator like "? ?" just wants to recognize certain strings inside that also happen to be valid infix operators.] "is cloned("BEGIN")" Perhaps this is an alternate way of specifying the parsing and semantics of a macro or function. Or perhaps not. Just an idea for now... "is cached" This is the English translation of what some otherwise sane folks call "memoization". This trait asserts that Perl can do automatic caching of return values based on the assumption that, for any particular set of arguments, the return value is always the same. It can dramatically speed up certain kinds of recursive functions that shouldn't have been written recursively in the first place. ";-)" "is inline" This says you think performance would be enhanced if the code were inlined into the calling code. Of course, it also constitutes a promise that you're not intending to redefine it or wrap it or do almost anything else fancy with it, such as expecting it to get called by a method dispatcher. In early versions of Perl 6, it's likely to be completely ignored, I suspect. (If not, it's likely to be completely broken...) "PRE"/"POST"/"FIRST" /"LAST"/etc. These all-caps traits are generally set from the inside of a subroutine as special blocks. "FIRST" and "LAST" are expected to have side effects. "PRE" and "POST" are expected to not have side effects, but return a boolean value indicating whether pre/post conditions have been met. If

Related: perl perl6 larry wall apocalypse