Planet Perl Six

Updated rakudo ROADMAP

2008-11-18T06:03:52+00:00

Tonight I updated Rakudo's ROADMAP file to reflect the progress we've made since it was last done (August 2008, YAPC::EU). At first I thought there wouldn't be much to update, but it turns out we've accomplished a fair bit.

More importantly, more infrastructure pieces are falling into place so that the remaining items become even easier than they were before. I expect to see good progress during the next month or so.

This weekend many of us attended the Parrot Developer's Summit to plan the way forward to Parrot 1.0 (March 2008). In parallel several of us also made plans for Rakudo's development in that time -- our goal is to have Rakudo on its own release cycle by then. I very much like the way the time-based monthly release cycle has worked for Parrot development, so we will undoubtedly continue this in Rakudo. Development for Rakudo will continue to track the Parrot trunk for a while, and we'll time Rakudo releases to follow a few days after each Parrot release.

We'll put together more details as we get closer; until then we're continuing to work on feature development.

During my airplane travel and at the summit I was able to get a lot of work on fixing lexical variables in Parrot. Unfortunately I've also found several places where Parrot was not properly allocating and freeing contexts, so those need to be reviewed and fixed before we can merge the branch back into trunk. Initial tests show that the design itself appears to work as expected, so now it's just a matter of reviewing and repairing context handling in Parrot. I'm expecting (hoping) to merge the branch back into trunk sometime on Wednesday (after tomorrow's Parrot release), which will close out quite a few RT tickets.

A Roadmap from the Parrot Developer Summit

2008-11-16T06:40:03+00:00

I'm at the Parrot Developer Summit this weekend, with Allison, Patrick, Jerry Gay, Klass-Jan Stol, Stephen Weeks, Kevin Tew, Jonathan Worthington, Jeff Horwitz, and Abhijit Mahabal. Our main goal was to create a roadmap toward production-ready releases of Parrot.

One of my early suggestions was to define a single-sentence vision for each milestone release.

Our tentative plan (to which we all agreed) is to continue monthly releases indefinitely. Language implementors can (of course, as currently) track our trunk, or our monthly releases, but we've decided to produce two milestone releases each year which represent a good stable point on which to host a language.

Our plan is to produce the first of these milestone releases in March and the second in July. Subsequent milestone releases will occur ever six months: January and July. Here's our vision list for the next six milestone releases:

March 2009: a stable API for language implementors, and the point at which we believe Parrot is an attractive platform to begin implementing languages, at least for people who don't want to track our trunk.
July 2009: integration and interoperability, the point at which we provide the next generation of tools to make implementing languages even easier.
January 2010: production readiness, the point at which Parrot is ready for your business.
July 2010: portability, the point at which we branch out beyond our three core platforms to other devices and systems.
January 2011: independence, the point at which Parrot is independent of the last remnants of non-Parrot build systems.
July 2011: magical wishlist items, the point at which Parrot supports wonderful exotic features that many other virtual machines may never support.

We're concentrating our efforts on the March release. Our schedule is aggressive, but it's workable. (We invested two hours in two agile planning exercises to identify, prioritize, and cluster features into the six milestones we've identified.) There's plenty of work to do, especially for novices and interested neophytes. In particular, we could use people to help us identify missing documentation and to ensure that it's clear and appropriate -- not to mention people interested in running tests, triaging bugs, and learning how to use the system.

We'll have more to say in the coming weeks, but I think you'll be very impressed at our progress over the next couple of releases.

Perl 6 Design Minutes for 12 November 2008

2008-11-14T07:10:32+00:00

The Perl 6 design team met by phone on 12 November 2008. Larry, Allison, Patrick, Jerry, Will, Nicholas, Jesse, and chromatic attended.

Allison:

we have two sponsors now, BBC and ActiveState
starting conversations with a few others
it helps to have two already
mainly focused on the IO milestone milestone
will merge back in two stages
stage one is getting the new IO system working
you can use it as an object
adds just one test file
I can have all of the different architectures report any failures with that test file
will merge in the bigger change later
though it's a simpler change
replace calls to the existing system with calls to the new system
hope it'll be a smooth transition
fixed up some calling conventions stuff last night for Andrew Whitworth
some pieces weren't working for him
committed a small patch to fix them, and explained it

Jerry:

the first Parrot Developer Summit is this weekend
for people who don't know about it, it's too late to attend
there may be a dozen or so of us meeting
intent is to hammer out a roadmap for 1.0
lots of questions on the channel and mailing lists about when there will be Parrot 1.0
good, I suppose

Patrick:

Christmas Eve!

Jerry:

they've given up asking about Perl 6

Jesse:

good!

Jerry:

I don't have an answer yet
but our work this weekend will let us decide what we need to release 1.0
also had a grant approved
designing and implementing Perl 6 command line syntax
already started the work
researching other dynamic languages and compilers
most languages have just grown their syntax over time
it's kind of messy
have put together some ideas
discussed them with Larry
expect that to continue, until I have a design document that I can send for review
then I'll move on to implementation
all laid out in the grant proposal on TPF's site

Jesse:

expect me to harass you occasionally

Patrick:

things are going well
lots of additions to Rakudo this week
I fixed the string semantics
classes can override how objects report stringification
Jonathan, Jerry, and I fixed Rakudo's container semantics
it does references correctly
fixed a lot of bugs and closed a lot of tickets
Jonathan started and I finished getting pointy blocks to work on flow control statements other than for
waiting for answers on repeat while and repeat until

Larry:

me too

Patrick:

when one of us gets the answer, he should let the other one know
completely refactored Rakudo's junctions
worked on the assignment metaoperators, such as += and *=
work correctly on protoobjects
I'm refactoring those now
will cause regression in one test that doesn't work right anyway
Rakudo is now over the 4500 passing test mark
we should get quite a few more over the next week or so
Jonathan and I will continue closing things out
worked more on the design of lexicals
continuing to update the document on my website
need to figure out autoclose in my head
Jonathan and I will hack on that this weekend
I could use his expertise in Parrot internals
also had a grant approved

Larry:

went to the hackers conference this last weekend
high point was teaching Don Knuth how to decode his Korean email

Jesse:

I thought he had no email!

Larry:

refactored the compile-time variables
there are no version-specific ones remaining
now $?OS, $?DISTRO, and $?VM variable
generalized matching against pairs to call a method corresponding to the name on whatever the object is, matching against whatever the argument is
sort of inside out as to what named arguments in BUILD routines do
refactored the :pair-named methods
they were kind of grungy anyway
thinking about whether strings ought to have methods like .r and .w and .x
or whether you ought to coerce to some sort of File type

Patrick:

I lean toward coercion

Larry:

everyone does
I just want to think it through
decided that .perl isn't special to junctions
if you use it on one, it autothreads
if you stringify that junction, it produces a result as if you'd done .perl on the whole junction
stringification on a junction produces Perl-style syntax
if you smart match a hash against a pair pattern, it tests the key and the value for matching
factoring out various amounts of boilerplate from the Perl 5 emitted code
simplifying code
fixed bugs with node wrapping
confused people looking at ASTs
chopped out TRE
discovered that my stupid LTM emulation ran twice as fast as the TRE code
that was eye-opening
STD now recognizes ::T as defining a valid type for later in the same scope
did some work to set up the infrastructure for STD to handle lexical scopes
nested pads
should have declarations in the right scope
part of the motivation
besides better error handling
set up a mechanism to define a prelude
freeze the lexical environment for the prelude
then slurp that up into STD
mundane functions and operators will probably end up there
have most of an implementation of a trie engine
that'll replace my stupid LTM
should evolve eventually into a full DFA
almost works
should run faster
and cut down on the on-disk cache
for various definitions of "should"

mostly fixing bugs
trying to keep blockers from blocking people
adding a little polish here and there to make people work better
thinking about our release process post 1.0
will talk about that this weekend

Will:

spending most of my time deleting things from Parrot
ripping out deprecated features
everything that's in there, some goes back to 0.5
but everything in there now we can rip out before the next release
sad that I'll miss the summit this week

Nicholas:

I'm the new grant manager for Dave Mitchell doing 5.10.1
announced the end-of-life for 5.8.x
surprised that no one told me I couldn't say that
if the Parrot Foundation is capable of raising money from people, how come TPF isn't?

Allison:

I tried to do something similar for TPF four years ago
it was very uncomfortable for the Perl community
lots of pushback
they wanted guarantees that no company would have control over the development of Perl

no one has control over the development of Perl!

Allison:

also the amount of money required for Perl 5 is much larger
it's not about money for Parrot
four memberships for Parrot is enough to push toward 1.0
we're a small project

Jerry:

have Perl 5 releases been sponsored before?
seems like a good thing

Jesse:

last week in China for the Beijing Perl Workshop
it was a lovely workshop
chatted with a lot of people about the state of Perl 6 and how they could get involved
offered to make lots of introductions
haven't taken anyone up on that yet
the Perl problem in China is that they're having a hard time finding competent Perl hackers
people are afraid to learn Perl because that'll make them unpalatable to the workforce
universities only teach C
people study on their own to learn C# and Java
most of the hiring firms really want C# and Java from their developers

Patrick:

in Rakudo, over the past week, I'm seeing lots of segfaults in different places
suspect it might be something that Jonathan and I did
have no clue where to start looking
it shows up in the regression suites
can point you to specific instances of things that fail

Will:

I can help narrow it down to PIR if you have a specific test that fails

Patrick:

they really float around
showed up in the assignment tests this morning
a couple of revisions later, they don't show up later
only some of them does -G help
the weird one this morning
if I run it from Parrot with the command line, I get a segfault
from the test harness, I don't
that seems backwards

Allison:

the test harness has more strict flags turned on

Patrick:

at one time, it used a different runcore

if there's a short PIR test case, we may be able to do a binary search

Patrick:

it's hard to give a short PIR case
the segfault moves around so much

The world according to .PARROT

2008-11-13T22:45:36+00:00

In Rakudo we have a number of places where bits of Parrot poke out from underneath the covers at inconvenient times; masak, moritz, and chrisdolan have been particularly good at finding these, especially when dealing with strings in Rakudo.

When we get HLL mapping fully working in Rakudo then a lot of these will go away; in the meantime I've been trying to explain what's happening "behind the scenes" that cause the seemingly bizarre behaviors. But yesterday I decided it would be better to provide a way to remove the covers entirely...

So, Rakudo now has a .PARROT method that reports the underlying Parrot data type for an object. This is in contrast to .WHAT, which gives back the (sometimes imperfect) Perl 6 view of an object.

Here's an example involving %*ENV -- normally we expect values in %*ENV to be (Perl6) Str objects, but the current implementation of %*ENV tends to give us String PMCs. But rakudo considers Parrot String and Perl 6 Str to have the same .WHAT protoobject, so it looks like it's a 'Str'.

> say %*ENV; /home/pmichaud
> say %*ENV.WHAT;
Str

The new .PARROT method lets us view the true identity of an object:

> say %*ENV.PARROT;
String

This still doesn't fix the problem, but at least it gives some transparency into what's going on.

I also adjusted the value semantics for the String PMC so that it auto-promotes to a Perl 6 Str object whenever it's asked for its scalar value. That should make it easier to get things into the form needed to get work done, at least until we can complete our other transitions that make this more seamless.

Rakudo any/all/none junctions now collapse

2008-11-13T20:18:28+00:00

For those who are wondering what happened to my journal posts over the past couple of months -- I've been focusing on some underlying Rakudo/Parrot design issues and supporting others more than writing code or prose. Also, I think I needed a bit of a break.

I've decided that it'll be easier (and thus more likely) for me to increase visibility on Rakudo progress if I blog about new features and decisions as they happen rather than try to batch them up for a post every few days. I do still plan to come up with "weekly summaries" as well, but I figure the immediate posts will be more satisfying for me and more helpful for others.

So, here's the first such post -- earlier this week I refactored Rakudo's Junction implementation to be cleaner and more correct, and bacek++ provided a patch to collapse duplicate values of one, any, and none Junctions. We had to wait for confirmation from perl6-language for this, which we just got today. So, we now have:

> say any(1,2,2,1,3,2).perl;
any(1, 2, 3);
> say (any(1,2,3) % 2).perl;
any(1, 0);

Although any/all/none junctions collapse, one() junctions do not:

> say (one(1,2,2,1,3,2) % 2).perl
one(1, 0, 0, 1, 1, 0)

This is because duplicate values change the boolean meaning of a one() junction, so we can't simply collapse them. As Larry says, "... one() junctions produce bags rather than sets."

As a result we've been able to unfudge more spectest for rakudo -- we're currently (r32625) passing 4598 spectests.

Perl 6 Tidings for November 2008

2008-11-09T21:22:08+00:00

Specification

A couple of small improvements to the spec made me a bit happier this past week:

There's now a Nil type. A Nil represents the empty list, but unlike a normal List object it is undefined in scalar context. It is returned by a bare return statement.
A cleanup of the global variables added (among other things) a $?VM variable, which holds informations about the backend being used to execute some code. I like this very much because currently some tests use the unspecced $?PUGS_BACKEND variable, which of course breaks other implementions.
File test operators look like this in Perl 6 $filename ~~ :e. This used to boil down to calling the method :e in class Str, which was a bit messy, because colons are not part of an identifier, and thus :e wasn't really a valid method name. Now this is special-cased in the smart match operator instead, and the method is named without the colon.

The smart links in the synopsis documents at http://perlcabal.org/syn/ now contains syntax hilighted code.

Implementations

SMOP

In his report to the TPF grant comittee Daniel Ruoso informed us about his work to integrate SMOP into Perl 5 by means of writing an XS module.

I'm not sure how much you can actually do with it right now, but it seems like an important proof-of-concept.

Rakudo

Jonathan and Patrick refactored Rakudo's handling of containers and values, to great success. This resulted in quite a few tickets being closed, and some more passing spec tests. Great work!

It's now also possible to define custom stringification routines for your classes (what's called "overloading" in Perl 5).

Last but not least, both Patrick Michaud and Jerry Gay received grants from Ian Hague's fanastic donation. Patrick will work on protoregexes and longest token matching (LTM) as well as the prerequisites to use external libraries (which is needed if you want to write the prelude in Perl 6 - guess what the plan is...).

(I've tried to explain the importance of LTM in this article, but I'm not sure if I succeeded. Anyway, it's essential for parsing Perl 6 correctly.

Marketing Position

2008-11-08T11:29:48+00:00

Sometimes I wonder what would happen if we gave Perl 6 the slogan "Yes we can!" and promoted it as "Real, effective change!" Maybe people could stop feeling ashamed of programming again.

Perl 6 Design Minutes for 05 November 2008

2008-11-07T20:39:49+00:00

The Perl 6 design team met by phone on 05 November 2008. Larry, Allison, Patrick, Jerry, Will, Nicholas, and chromatic attended.

Larry:

the specs officially define a Nil type that is the meaning of ()
an undef that's undef in item context
otherwise, just a null list
just to clarify the semantics of what it means to say return;
answered Patrick's email about autothreading of junctions over method calls
I think that doesn't have much impact on specs
we can clarify if necessary
in terms of hackery, I've done a lot of work on cursor and STD and gimme5
optimizations and simplifications
preparing to get rid of TRE in the lexer
threw a lot of stuff out of cursors themselves
they no longer track the original string or positional memos in the Perl 5 version
nor do they distinguish a to attribute anymore
an unbound cursor only as a position
a bound cursor has a from
for ratchety kind of matching, all it does is modify the position in a mutable cursor
rather than copying cursors, which is fairly expensive
a little more efficient
made the tryfile syntax checker work on multiple test files
keeps it from having to recompile the standard grammar on every test
it does leak rather badly
you can't parse the entire test suite with one invocation, unless you have a lot of virtual memory
refactoring the various methods which determine cursors to try to make decisions earlier
don't have to make extra function calls to make a decision which should be made at a higher level
some speed gains, some preparation for lexer changes
another preparation is to start emulating NFG semantics
when I set up for the original parse, I now do an unpack "U*" as an emulation of NFG
one integer per character
some of my tests in my regex emulation now test against that array
rather than against the original string
it runs no slower, even accounting for the conversion
eventually the lexing I want to do with a homebrew DFA matcher will use that integer array directly
probably also buys some efficiency
Perl 5 is not very efficient about recalculating positions
it only caches a few UTF-8 positions for a string
if I'm bouncing back and forth between the beginnings and endings of tokens, it has to keep recalculating UTF-8 from one direction or the other
the net NFG will be a win
even if some tests need to use the string version
still planning to get rid of TRE
the workarounds cause the lexer to take half a GB of disk space
hope it'll run faster too

Patrick:

worked on exceptions in Parrot
mostly identifying places where the spec needs work, or how they don't work as I expect them
answering questions about the specification
worked on lexical variable handling in Parrot
tomorrow, Jonathan and I will switch over to the new container/value semantics so they work properly

does that fix list assignment?

Patrick:

it's necessary, but not sufficient
PCT also needs some changes

Jerry:

worked on some refactoring of Rakudo's action grammar
action methods
there were many different types of calls into the metaobject
it was quite a mess
I implemented an isa method on PCT's Node class
converted Rakudo to use that instead of .WHAT or .HOW.isa
definitely more refactoring to do in the action methods
I'll attack that as I can
Jonathan made some changes to Rakudo's use
instead of compile time, it happens at INIT time
precompiled modules work now
but it's still a hack
use shouldn't be done at INIT time
his changes necessitated changes to my import patch

Patrick:

that was the case anyway

Jerry:

I knew that was the case
I just need the time to rework that
still preparing for the Parrot Developer Summit
again, that will continue until after it happens

Will:

did some Parrot work this week
fixed up the sub-level tracing that's been broken for some of the more complex code
turned out to be a cut-and-paste job from something Jonathan had done for Rakudo in Perl 6
trying to go through the deprecated list, getting rid of some low-hanging fruit
deleted quite a bit of code this week
looking at the tracing stuff to help me figure out where Tcl is spending most of its time
we seem to be invoking PGE a lot
looking forward to some of the work Patrick has on his plate
hopefully that'll get Tcl and Perl 6 running faster

I fixed some bugs
fixed some crash bugs
found some new crash bugs and fixed them
also trying to remove deprecated code
tracking down some other crash bugs, but they're tricky
cleaning up code is a priority there
still thinking about how to do PIR-level profiling
we sorely need it

Nicholas:

the release candidate didn't get out last weekend
still might not get out this weekend
waiting on a CPAN release of File::Path

Patrick:

remember that there are two init times
there's the semantics of Perl 6 INIT block
there's the Parrot sub :init as well

Jerry:

I meant the Perl 6 version

Patrick:

there's nothing prior to :init in Parrot terms, if you're talking about Parrot
we have to keep that in mind

Jerry:

Jonathan pushes onto $?INIT in the Perl 6 terms

Patrick:

it has to happen earlier than that

Nicholas:

Larry, what version of Perl are you using, in terms of UTF-8 slowness?

Larry:

5.10
it does some caching of pos
but if your lexer runs back and forth to test the same thing various times, it still has to do some stuff

Nicholas:

it ought to be able to store three or more positions
might be as simple as a #define
I haven't done that

Larry:

I'm moving away from the whole UTF-8 model anyway toward the NFG model
that unpack is amazingly fast
I thought I'd lose some time, but it was just as fast
maybe that's some kind of indication that we're going the right direction
I'm not actually doing NFG, just assuming I'm in NFC form
NFC is a subset of NFG

Jerry:

with this approach, will you always need a hybrid solution?

Larry:

it depends on what your VM is

we can recommend one for you

Larry:

some things are easier to check in Perl 5 with the string matching
no decent way I know of to ask whether a particular character number matches a particular character class
I'd have to convert it to a string, then do a pattern match against it
as far as I know
unless you're aware of a way in which of saying "Is character #582 an alphanumeric?"

Nicholas:

I assume you can hijack UTF-8 swatch caches to figure that out in Perl 5

Larry:

it would take an XS hack right now
don't think those are exposed at the integer level

Nicholas:

part of that is implemented as Perl 5
converted to XS, at least the slowest parts

Larry:

I doubt it would be difficult to make an API for direct access in a version of Perl
it wouldn't be in the current version

Nicholas:

not likely to be sufficiently faster, when you account for developer time

Larry:

essentially, I'm matching against UTF-32

Patrick:

do we have a good idea or list of what methods are defined on junctions?

Larry:

there's probably a secret method name which does the autothreading, which Object delegates to
other than that, maybe some methods to extract out the bits of it
they would not have to be human readable
I'd de-Huffmanize those names to prevent accidentally running into them

Jerry:

this came up with regard to any container, not just junctions
how do you call a method on a container, not something that hypers over the values?

Patrick:

it's not automatic, as it is with junctions
the method that kept coming up in my mind is .values to grab the values out of the junction

Larry:

there'll be a method to do that, but not with that name
.junction_values
something unlikely to collide with anything else

Patrick:

there was a discussion about stringification being made special somehow
the printed stringification and default stringification might be different
the .perl method on a junction might return a list of strings, rather than a string
how do we get a string that contains the junction operator in the middle, rather than a junction of two strings
has that made it into Synopses somehow?

Larry:

a multimethod which converts a junction to a string will fire directly without autothreading
Str(Junction)

Patrick:

it's a method, not a function?

Larry:

it doesn't really matter, as long as it's defined within Junction

Patrick:

Junction.Str always gets that version, and does an autothread?

Larry:

if a Str method is defined in Junction then it won't autothread
only autothreads if Object gets the method dispatch.
always produces a string which looks as if it came from .perl
everything falls out of the current mechanism
we don't have to define special cases

Patrick:

one more question
what is the syntax for matching a string or object against a specific rule within a grammar?
a lot of people have smart matched against the name of the rule

Larry:

underneath, you create a match
then just call a method on that
the method is the rule
how much syntactic sugar we want to wrap around that, I'm not sure

Patrick:

can I tell people that they're doing it wrong?

Larry:

it probably is, yes
it sounds wrong, without seeing it

Patrick:

essentially $variable ~~ Gramar::Rule_Name

Larry:

that seems unlikely to work without someone deciding to create the match
it's possible the smart match operator could be smart enough to do that

Patrick:

if I do $variable ~~ sub

Larry:

that depends on the arity of the sub
similar distinction
"Oh, this is actually a method"
presumably of zero arity, except for the invocant
essentialy the string has to be passed in as the invocant

Patrick:

that is one of those things where the smart match is macro-like
it recognizes that it's a sub, not a list operator

Larry:

it recognizes a routine of some sort
it needs to know that it's a method from just inspection
just naming a method doesn't give it enough information
unless you put it in method form...

Patrick:

leave methods out of it for now
does that syntax check the arity of a sub against something
or does it treat it as a list op?

Larry:

it'll call the sub with the left-hand argument as the first argument

Jerry:

as opposed to $variable ~~ &sub

Patrick:

normally a sub name in a term position is a listop

Larry:

seems like it still is
I don't think it'll work without the ampersand
you have to allow a general expression on the right to return a value to smart match
you need explicit curlies or the ampersand

Jerry:

in the recent past, I remember discussions with the PPI folks that Perl 6 can't parse Perl 6 any better than Perl 5 can parse Perl 5
although things aren't perfect with the parse yet or STD
and we aren't using BEGIN and macros yet
azawawi has created a syntax highlighter based on STD
it's really cool
feather has syntax-highlighted versions of all of the spec tests
they're linked from spec.pugscode.org
you can see syntax-highlighted Perl 6 today
hasn't been reported anywhere
definitely worth mentioning
effectively a built-in

Regexes strike back

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 19 - Regexes strike back

SYNOPSIS

    # normal matching:
    if 'abc' ~~ m/../ {
        say $/;                 # ab
    }

    # match with implicit :sigspace modifier
    if 'ab cd ef'  ~~ mm/ (..) ** 2 / {
        say $1;                 # cd
    }

    # substitute with the :sigspace modifier
    my $x = "abc     defg";
    $x ~~ ss/c d/x y/;
    say $x;                     # abx     yefg

DESCRIPTION

Since the basics of regexes are already covered in lesson 07, here are some useful (but not very structured) additional facts about Regexes.

Matching

You don't need to write grammars to match regexes, the traditional form m/.../ still works, and has a new brother, the mm/.../ form, which implies the :sigspace modifier. Remember, that means that whitespaces in the regex are substituted by the <.ws> rule.

The default for the rule is to match \s+ if it is surrounded by two word-characters (ie those matching those \w), and \s* otherwise.

In substitutions the :samespace modifier takes care that whitespaces matched with the ws rule are preserved. Likewise the :samecase modifier, short :ii (since it's a variant of :i) preserve case.

    my $x = 'Abcd';
    $x ~~ s:ii/^../foo/;
    say $x;                     # Foocd
    $x = 'ABC'
    $x ~~ s:ii/^../foo/;
    say $x                      # FOO

This is very useful if you want to globally rename your module Foo, to Bar, but for example in environment variables it is written as all uppercase. With the :ii modifier the case is automatically preserved.

It copies case information on a character by character. But there's also a more intelligent version; when combined with the :sigspace (short :s) modifier, it tries to find a pattern in the case information of the source string. Recognized are .lc, .uc, .lc.ucfirst, .uc.lcfirst and .lc.capitaliz (Str.capitalize uppercases the first character of each word). If such a pattern is found, it is also applied to the substitution string.

    my $x = 'The Quick Brown Fox';
    $x ~~ s :s :ii /brown.*/perl 6 developer/;
    # $x is now 'The Quick Perl 6 Developer'

Alternations

Alternations are still formed with the single bar |, but it means something else than in Perl 5. Instead of sequentially matching the alternatives and taking the first match, it now matches all alternatives in parallel, and takes the longest one.

    'aaaa' ~~ m/ a | aaa | aa /;
    say $/                          # aaa

While this might seem like a trivial change, it has far reaching conseqeunces, and is crucial for extensible grammars. Since Perl 6 is parsed using a Perl 6 grammar, it is responsible for the fact that in ++$a the ++ is parsed as a single token, not as two prefix:<+> tokens.

The old, sequential style is still available with ||:

    grammar Math::Expression {
        token value {
            | <number>
            | '(' 
              <expression> 
              [ ')' || { fail("Parenthesis not closed") } ]
        }

        ...
    }

The { ... } execute a closure, and calling fail in that closure makes the expression fail. That branch is guaranteed to be executed only if the previous (here the ')') fails, so it can be used to emit useful error messages while parsing.

There are other ways to write alternations, for example if you "interpolate" an array, it will match as an alternation of its values:

    $_ = '12 oranges';
    my @fruits = <apple organge banana kiwi>;
    if m:i:s/ (\d+) (@fruits)s? / {
        say "You've got $0 $1, I've got { $0 + 2 } of them. You lost.";
    }

There is yet another construct that automatically matches the longest alternation: mutli regexes. They can be either written as multi token name or with a proto:

    grammar Perl {
        ...
        proto token sigil { ... }
        token sigil:sym<$> { <sym> }
        token sigil:sym<@> { <sym> }
        token sigil:sym<%> { <sym> }
        ...

       token variable { <sigil> <twigil>? <identifier> }
   }

This example shows multiple tokens called sigil, which are parameterized by sym. When the short name, ie sigil is used, all of these tokens are matched in an alternation. You may think that this is a very inconvenient way to write an alternation, but it has a huge advantage over writing '$'|'@'|'%': it is easily extensible:

    grammar AddASigil is Perl {
        token sigil:sym<!> { <sym> }
    }
    # wow, we have a Perl 6 grammar with an additional sigil!

Likewise you can override existing alternatives:

    grammar WeirdSigil is Perl {
        token sigil:sym<$> { '°' }
    }

In this grammar the sigil for scalar variables is °, so whenever the grammar looks for a sigil it searches for a ° instead of a $, but the compiler will still know that it was the regex sigil:sym<$> that matched it.

In the next lesson you'll see the development of a real, working grammar with Rakudo.

Containers and Values

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 10 - Containers and Values

Synopsis

    my ($x, $y);
    $x := $y;
    $y = 4;
    say $x;             # 4
    if $x =:= $y {
        say '$x and $y are different names for the same thing'
    }

DESCRIPTION

Perl 6 distinguishes between containers, and values that can be stored in containers.

A normal scalar variable is a container, and can have some properties like type constraints, access constraints (for example it can be read only), and finally it can be aliased to other containers.

Putting a value into a container is called assignment, and aliasing two containers is called binding.

    my @a = 1, 2, 3;
    my Int $x = 4;
    @a[0] := $x;     # now @a[0] and $x are the same variable
    @a[0] = 'Foo';   # Error 'Type check failed'

Types like Int and Str are immutable, ie the objects of that type can't be changed; but you can still change the variables (the containers, that is) which hold these values:

    my $a = 1;
    $a = 2;     # no surprise here

Binding can also be done at compile time with the ::= operator.

You can check if two things are bound together the =:= comparison operator.

MOTIVATION

Exporting and importing subs, types and variables is done via aliasing. Instead of some hard-to-grasp typeglob aliasing magic, Perl 6 offers a simple operator.

Rules (formerly Regexes)

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 07 - Rules (formerly Regexes)

SYNOPSIS

    grammar URL {
        token TOP {
            <schema> '://' 
            [<hostname> | <ip> ]
            [ ':' <port>]?
            '/' <path>?
        }
        token byte {
            (\d**{1..3}) <?{ $0 < 256 }>

        }
        token ip {
            <byte> [\. <byte> ] ** 3
        }
        token schema {
            \w+
        }
        token host {
            (\w+) ( \. \w+ )*
        }
        token port {
            \d+
        }
        token path {
            <[a..zA..Z0..9-_.!~*'():@&=+$,/]>+

        }
    }

DESCRIPTION

Regexes are one of the areas that has been improved and revamped most in Perl 6. To honour that, an because they aren't "regular expressions" any more, they are now called "rules".

There are three large changes and enhancements to the regexes

Syntax clean up

Many small changes make rules easier to write. For example the dot . matches any character now, the old semantics (anything but newlines) can be achieved with \N.

Modifiers now go at the start of a regex, and non-capturing groups are [..], which are a lot easier to write than the old (?:...).

Nested caputures and match object

In perl 5, a regex like this (a(b))(c) would put ab into $1, b into $2 and c into $3 upon successful match. This has changed. Now $0 (enumeration starts at zero) contains ab, and $0[0] or $/[0][0] contains b. $1 holds c.

Named Rules and Grammars

You can declare regexes with names just like you can with subs and methods. You can refer to these inside other rules with <name>. And you can put multiple rules into grammars, which are just like classes and support inheritance and composition

These changes make rules much easier to write and maintain than Perl 5 regexes.

All of these changes go quite deep, and only the surface can be scratched here.

Syntax clean up

Letter characters (ie underscore, digits and all Unicode letters) match literally, and have a special meaning (they are "metasyntactic") when escaped with a backslash. For all other characters it's the other way round - they are metasyntactic unless escaped.

    literal         metasyntactic
    a  b  1  2      \a \b \1 \2
    \* \: \. \?     *  :  .  ?

Not all metasyntactic tokens have a meaning (yet). It is illegal to use those without a defined meaning.

There is another way to escape strings in regexes: with quotes.

    m/'a literal text: $#@!!'/

The changed semantics of . has already been mentioned, and that [...] are now non-capturing groups. Char classes are <[...]>, and negated char classes <-[...]>. ^ and $ always match begin and end of the string, to match begin and end of lines use ^^ and $$.

This means that the /s and /m modifers are gone. Modifiers are now given at the start of a regex, and are spelled as pairs.

    if "abc" ~~ m:i/B/ {
        say "Match";
    }

Modifiers have a short and a long form. The old /x modifier is now the default, i.e. white spaces are ignored.

    short   long            meaning
    -------------------------------
    :i      :ignorecase     ignore case (formerly /i)
    :a      :ignoreaccents  ignore accents
    :g      :global         match as often as possible (/g)
    :s      :sigspace       Every white space in the regex matches
                            (optional) white space
    :P5     :Perl5          Fall back to Perl 5 compatible regex syntax
    :4x     :x(4)           Match four times (works for other numbers as well)
    :3rd    :nth(3)         Third match
    :ov     :overlap        Like :g, but also consider overlapping matches
    :ex     :exhaustive     Match in all possible ways
            :ratchet        Don't backtrack

The :sigspace needs a bit more explanation. It replace all whitespaces in the pattern with <.ws> (that is it calls the rule ws without keeping its result). You can override that rule. By default it matches one or more white spaces if it's enclosed in word characters, and zero or more otherwise.

(There are more new modifiers, but probably not as important as the listed ones).

The Match Object

Every match generates a so-called match object, which is stored in the special variable $/. It is a versatile thing. In boolean context it returns Bool::True if the match succeeded. In string context it returns the matched string, when used as a list it contains the positional captures, and when used as a hash it contains the named captures. The .from and .to methods contains the first and last string positions of the match.

    if 'abcdefg' ~~ m/(.(.)) (e | bla ) $<foo> = (.) / {
        say $/[0][0];           # d
        say $/[0];              # cd
        say $/[1];              # e
        say $/<foo>             # f
    }

$0, $1 etc are just aliases for $/[0], $/[1] etc. Likewise $/<x> and $/{'x'} are aliased to $<x>.

Note that anything that you access via $/[...] and $/{...} is a match object again. This allows you to build real parse trees with rules.

Named Rules and Grammars

Rules can either be used with the old style m/.../, or be declared like subs and methods.

    regex a { ... }
    token b { ... }
    rule  c { ... }

The difference is that token implies the :ratchet modifier (which means no backtracking, like a (?> ... ) group around each part of the regex in perl 5), and rule implies both :ratchet and :sigspace.

To call such a rule (we'll call them all rules, independently with which keyword they were declared) you put the name in angle brackets: <a>. This implicitly anchors the sub rule to its current position in the string, and stores the result in the match object in $/<a>, ie it's a named capture. You can also call a rule without capturing its result by prefixing its name with a dot: <.a>.

A grammar is a group of rules, just like a class (see the SYNOPSIS for an example). Grammars can inherit, override rules and so on.

    grammar URL::HTTP is URL {
        token schema { 'http' }
    }

MOTIVATION

Perl 5 regexes are often rather unreadable, the grammars encourage you to split a large regex into more readable, short fragments. Named captures make the rules more self-documenting, and many things are now much more consistent than they were before.

Finally grammars are so powerful that you can parse about every programming language with them, including Perl 6 itself. That makes the Perl 6 grammar easier to maintain and to change than the perl 5 one, which is written in C and not changable at parse time.

Introduction

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" - Introduction

SYNOPSIS

    Learn Perl 6 (if you already know Perl 5)
    Learn to love Perl 6
    Understand why

DESCRIPTION

Perl 6 is underdocumented. That's no surprise, because (apart from the specification) writing a compiler for Perl 6 seems to be much more urgent than writing documentation that targets the user.

Unfortunately that means that it's not easy to learn Perl 6, and that you have to have a profound interest in Perl 6 to actually find the motivation to learn it from the specification, IRC channels or from the test suite.

This project, which I'll preliminary call "Perl 5 to 6" (in lack of a better name) attempts to fill that gap with a series of short articles.

Each lesson has a rather limited topic, and tries to explain the two or three most important points with very short examples. It also tries to explain why things changed from Perl 5 to 6, and why this is important. I also hope that the knowledge you gain from reading these lessons is enough to basically understand the Synopsis, which are the canonical source of all Perl 6 wisdom.

To keep the reading easy, each lesson should not exceed 200 lines or 1000 words (but it's a soft limit).

Perhaps the lessons are too short to learn a programming language from them, but I hope that they draw an outline of the language design, which allows you to see its beauty without having to learn the language.

IT'S NOT

This is not a guide for converting Perl 5 to Perl 6 programs. It is also not a comprehensive list of differences. See http://svn.pugscode.org/pugs/docs/Perl6/Perl5/Differences.pod|Perl6::Perl5::Differences instead if you're looking for something like that.

ROADMAP

Already written or in preparation:

    00 Intro
    01 Strings, Arrays, Hashes
    02 Types
    03 Control structures
    04 Subs and Signatures
    05 Objects and Classes
    06 Contexts
    07 Rules
    08 Junctions
    09 Comparisons and Smartmatching
    10 Containers and Binding
    11 Basic Operators
    12 Lazyness
    13 Custom Operators
    14 the MAIN sub
    15 Twigils
    16 Enums
    17 Unicode
    18 Scoping
    19 More Regexes
    20 A Grammar for XML
    21 Subset types
    22 State of the Implementations
    23 Quoting and Parsing

Things that I want to write about, but which I don't know well enough yet:

    Macros
    Meta Object Programming
    Concurrency
    IO

Things that I want to mention somewhere, but don't know where

    .perl method

AUTHOR

Moritz Lenz, http://perlgeek.de/, moritz@faui2k3.org

Strings, Arrays, Hashes;

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 01 - Strings, Arrays, Hashes;

SYNOPSIS

    my $five = 5;
    print "an interpolating string, just like in perl $five\n";
    say 'say() adds a newline to the output, just like in perl 5.10';

    my @array = 1, 2, 3, 'foo';
    my $sum = @array[0] + @array[1];
    if $sum > @array[2] {
        say "not executed";
    }
    my $number_of_elems = @array.elems;     # or +@array
    my $last_item = @array[*-1];

    my %hash = foo => 1, bar => 2, baz => 3;
    say %hash{'bar'};                       # 2
    say %hash<bar>;                         # same with auto-quoting
    # this is an error: %hash{bar}

DESCRIPTION

Perl 6 is just like perl 5 - only better. Statements are terminated by semicolons. The after the last statement in a block and after a closing curly brace at the end of a line the semicolon is option.

Variables still begin with a sigil (like $, @, %), and many Perl 5 builtins are still mostly unchanged in Perl 6.

Strings

Strings are quoted with double quotes (in which case they are interpolating), or with single quotes. Backslash escapes work just like in Perl 5.

However the interpolation rules have changed a bit. The following things interpolate

    my $scalar = 6;
    my @array = 1, 2, 3;
    say "Perl $scalar";         # 'Perl 6'
    say "An @array[]";          # 'An 1 2 3'
    say "@array[1]";            # '2'
    say "Code: { $scalar * 2 }" # 'Code: 12'

Arrays and hashes only interpolate if followed by an index, empty indexes interpolate the whole data structure.

A block in curly braces is executed as a code block, and the result is interpolated.

Arrays

Arrays variables still begin with the @ sigil. And they always do, even if an index is present.

    my @a = 5, 1, 2;            # no parens needed anymore
    say @a[0];                  # yes, it starts with @
    say @a[0, 2];               # slices also work

Lists are constructed with the Comma operator. 1, is a list, (1) isn't.

Since everything is an object, you can call methods on arrays:

    my @b = @a.sort;
    @b.elems;                   # number of items
    if @b > 2 { say "yes" }     # still works
    @b.end                      # number of last index. Replaces $#array
    my @c = @b.map({$_ * 2 });  # map is also a method, yes

There is a short form for the old qw(..) quoting construct:

    my @methods = <shift unshift push pop end delete sort map>;

Hashes

While Perl 5 hashes are even sized lists, Perl 6 hashes are lists of pairs. Pairs are also used for other things, like named arguments to subs, but more on that later.

Just like with arrays the sigil stays invariant when you index it. And hashes also have methods that you can call on them.

    my %drinks =
        France  => 'Wine',
        Bavaria => 'Beer',
        USA     => 'Coke';

    say "The people in France love ",  %drinks{'France'};
    %drinks.delete('France');

Note that when you access hash elements with %hash{...}, the key is not auto quoted like in Perl 5. So %hash{foo} doesn't access index "foo", but calls the function foo(). The autoquoting isn't gone, it just has a different syntax:

    say %drinks<Bavaria>;

Final Notes

Most builtin methods exists both as a method and as a sub. So you can write both sort @array and @array.sort.

Finally you should know that both [..] and {...} are just method calls with a special syntax, not something tied to arrays and hashes. That means that they are also not tied to a particular sigil.

    my $a = [1, 2, 3];
    say $a[2];          # 3

This means that you don't need special dereferncing syntax, and that you can create objects that can act as arrays, hashes and subs at the same time.

Types

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 02 - Types

SYNOPSIS

    my Int $x = 3;
    $x = "foo";         # error
    say $x.WHAT;        # 'Int'
 
    # check for a type:
    if $x ~~ Int {
        say '$x contains an Int'
    }

DESCRIPTION

Perl 6 has types. Everything is an Object in some way, and has a type. Variables can have type constraints, but they don't need to have one.

There are some basic types that you should know about:

    'a string'      # Str
    2               # Int
    3.14            # Num
    (1, 2, 3)       # List

All "normal" builtin types begin with an upper case letter. All "normal" types inherit from Any, and absolutely everything inherits from Object.

You can restrict the type of values that a variable can hold by adding the type name to the declaration.

    my Num $x = 3.4;
    my Int @a = 1, 2, 3;

It is an error to try to put a value into a variable that is of a "wrong" type (ie neither the specified type nor a subtype).

A type declaration on an Arrray is used for its contents, so my Str @s is an array that can only contain strings.

Introspection

You can learn about the direct type of a thing by calling its .WHAT method.

    say "foo".WHAT;     # Str

However if you want to check if something is of a specific type, there is a different way, which also takes inheritance into account and is therefore recommended:

    if $x ~~ Int {
        say 'Variable $x contains an integer';
    }

MOTIVATION

The type system isn't very easy to grok in all its details, but there are good reasons why we need types:

Programming safety: If you declare something to be of a particular type, you can be sure that you can perform certain operations on it. No need to check.
Optimizability: When you have type informations at compile time, you can perform certain optimizations. Perl 6 doesn't have to be slower than C, in principle.
Extensibility: With type informations and multiple dispatch you can easily refine operators for particular types.

Basic Control Structures

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 03 - Basic Control Structures

SYNOPSIS

    if $percent > 100  {
        say "weird mathematics";
    }
    for 1..3 {
        # using $_ as loop variable
        say 2 * $_;
    }
    for 1..3 -> $x {
        # with explicit loop variable
        say 2 * $x;
    }

    while $stuff.is_wrong {
        $stuff.try_to_make_right;
    }

    die "Access denied" unless $password eq "Secret";

DESCRIPTION

Most Perl 5 control structures are quite similar in Perl 6. The biggest visual difference is that you don't need a pair of parenthesis after if, while, for etc.

Branches

if is mostly unchanged, you can still add elsif and else branches. unless is still there, but no else branch is allowed after unless.

    if $sheep == 0 {
        say "How boring";
    } elsif $sheep == 1 {
        say "One lonely sheep";
    } else {
        say "A herd, how lovely!";
    }

You can also use if and unless as a statement modifier, i.e. after a statements:

    say "you won" if $answer == 42;

Loops

You can manipulate loops with next and last just like in Perl 5.

The for-Loop is now only used to iterate over lists. By default the standard variable $_ is used, unless an explicit loop variable is given.

    for 1..10 -> $x {
        say $x;
    }

The -> $x { ... } thing is called a "pointy block" and is something like an anonymous sub, or a lambda in lisp.

You can also use more than one loop variable:

    for 0..5 -> $even, $odd {
        say "Even: $even \t Odd: $odd";
    }

This is also how you iterate over hashes:

    my %h = a => 1, b => 2, c => 3;
    for %h.kv -> $key, $value {
        say "$key: $value";
    }

The C-style for-loop is now called loop:

    loop (my $x = 1; $x < 100; $x = $x**2) {
        say $x;
    }

Subroutines and Signatures

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 04 - Subroutines and Signatures

SYNOPSIS

    # sub without a signature - perl 5 like
    sub print_arguments {
        say "Arguments:";
        for @_ {
            say "\t$_";
        }
    }

    # Signature with fixed arity and type:
    sub distance(Num $x1, Num $y1, Num $x2, Num $y2) {
        return sqrt ($x2-$x1)**2 + ($y2-$y1)**2;
    }
    say distance(3, 5, 0, 1); 

    # Default arguments
    sub logarithm($num, $base = 2.7183) {
        return log($num) / log($base)
    }
    say logarithm(4);       # uses default second argument
    say logarithm(4, 2);    # explicit second argument

    # named arguments

    sub doit(:$when, :$what) {
        say "doing $what at $when";
    }
    doit(what => 'stuff', when => 'once');  # 'doing stuff at once'
    doit(:when<noon>, :what('more stuff')); # 'doing more stuff at noon'
    # illegal: doit("stuff", "now")

DESCRIPTION

Subroutines are declared with the sub key word, and can have a list of formal parameters, just like in C, Java and most other languages. Optionally these parameters can have type constraints.

Parameters are read-only by default. That can be changed with so-called "traits":

    sub foo($bar) {
        $bar = 2;       # forbidden
    }

    my $x = 2;
    sub baz($bar is rw) {
        $bar = 0;         # allowed
    }
    baz($x); say $x;    # 0

    sub quox($bar is copy){
        $bar = 3;
    }
    quox($x); say $x    # 0

Parameters can be made optional by adding a question mark ? after them, or by supplying a default value.

    sub foo($x, $y?) {
        if $y.defined {
            say "WE CAN HAZ $y"
        }
    }

    sub bar($x, $y = 2 * $x) { 
        ...
    }

Named Parameters

When you invoke a subroutine like this: my_sub($first, $second) the $first argument is bound to the first formal parameter, the $second argument to the second parameter etc., which is why they are called "positional".

Sometimes it's easier to remeber names than numbers, which is why Perl 6 also has named parameters:

    my $r = Rectangle.new( 
            x       => 100, 
            y       => 200, 
            height => 23,
            width  => 42,
            color  => 'black'
    );

When you see something like this, you immediately know what the specific arguments mean.

To define a named parameter, you simply put a colon : before the parameter in the signature list:

    sub area(:$width, :$height) {
        return $width * $height;
    }
    area(width => 2,  height => 3);
    area(height => 3, width => 2 ); # the same
    area(:height<3>, :width<2>);    # the same

In these the variable name is used as the name. You can use a different name, though:

    sub area(:width($w), :height($h)){
        return $w * $h;
    }
    area(width => 2,  height => 3);

Named arguments can only be passed by name, not by position. On the other hand, positional arguments can be passed by name by default.

    sub sqrt($number) { ... };
    sqrt(3);
    sqrt(number => 3); # also works

Slurpy Arguments

Just because you give your sub a signature doesn't mean you have to know the number of arguments in advance. You can define so-called slurpy parameters (after all the regular ones) which use up any remaining arguments:

    sub tail ($first, *@rest){
        say "First: $first";
        say "Rest: @rest[]";
    }
    tail(1, 2, 3, 4);           # "First: 1\nRest: 2 3 4\n"

Interpolation

By default arrays aren't interpolated in argument lists, so unlike in Perl 5 you can write something like this:

    sub a($scalar1, @list, $scalar2){
        say $scalar2;
    }

    my @list = "foo", "bar";
    a(1, @list, 2);                  # 2

That also means that by default you can't use a list as an argument list:

    my @indexes = 1, 4;
    say "abc".substr(@indexes)       # error!

You can achieve the desired behaviour with a prefix |

    say "abcdefgh".substr(|@indexes) # bcde

Multi Subs

You can actually define multiple subs with the same name but with different parameter lists:

    multi sub my_substr($str) { ... }                          # 1
    multi sub my_substr($str, $start) { ... }                  # 2
    multi sub my_substr($str, $start, $end) { ... }            # 3
    multi sub my_substr($str, $start, $end, $subst) { ... }    # 4

Now whenever you call such a sub, the one with the matching parameter list will be chosen.

The multis don't have to differ in the arity (ie number of arguments), they can also differ in the type of the parameters:

    multi sub frob(Str $s) { say "Frobbing String $s"  }
    multi sub frob(Int $i) { say "Frobbing Integer $i" }

    frob("x")       # Frobbing String x
    frob(2)         # Frobbing Inteteger 2

MOTIVATION

Nobody will doubt the usefulness of explicit sub signatures: less typing, less duplicate argument checks, and more self-documenting code. The value of named parameters has also been discussed already.

Multi subs are very useful because they allow builtins to be overridden for new types. Let's assume you want a version of Perl 6 which is localized to handle turkish strings correctly, which have unsual rules for case conversions.

Instead of modifying the language, you can just introduce a new type TurkishStr, and add multi subs for the builtin functions:

    sub uc(TurkishStr $s) { ... }

Now all you have to do is to take care that your strings have the type that corresponds to their language, and then you can use uc just like the normal builtin function.

Since operators are also subs, that refinement works for operators too.

Objects and Classes

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 05 - Objects and Classes

SYNOPSIS

    class Shape {
        method area { ... }    # literal '...'
        has $.colour is rw;

    }

    class Rectangle is Shape {
        has Num $.width;
        has Num $.height;

        method area {
            $!width * $!height;
        }
    }

    my $x = Rectangle.new(
            width   => 30,
            height  => 20,
            colour  => 'black',
        );
    say $x.area;                # 600
    say $x.colour;              # black
    $x.colour = 'blue';

DESCRIPTION

Perl 6 has an object model that is much more fleshed out than the Perl 5 one. It has keywords for creating classes, roles, attributes and methods, and has encapsulated private attributes and methods.

There are two ways to declare classes

    class ClassName;
    # class definition goes here

The first one begins with class ClassName; and stretches to the end of the file. In the second one the class name is followed by a block, and all that is inside the blocks is considered to be the class definition.

    class YourClass {
        # class definition goes here
    }
    # more classes or other code here

Methods

Methods are declared with the method key word. Inside the the method you can use the self keyword to refer to the object on which the method is called (the invocant).

You can also give the invocant a different name by adding a first parameter to the signature list and append a colon : to it.

Public methods can be called with the syntax $object.method if it takes no arguments, and $object.method(@args) or $object.method: @args if it takes arguments.

    class SomeClass {
        # these two methods do nothing but return the invocant
        method foo {
            return self;
        }
        method bar($s: ) {
            return $s;
        }
    }
    my SomeClass $x .= new;
    $x.foo.bar                      # same as $x

(The my SomeClass $x .= new is actually a shorthand for my SomeClass $x .= SomeClass.new. It works because the type declaration fills the variable with a "proto object" of SomeClass, which is an object representation of the the type.)

Methods can also take additional arguments just like subs.

Private methods can be declared with my method, and called with self!method_name.

    class Foo {
        my method private($frob) {
            return "Frobbed $frob";
        }

        method public {
            say self!private("foo");
        }
    }

Private methods can't be called from outside the class.

Attributes

Attributes are declared with the has key word, and have a "twigil", that is a special character after the sigil. For private attributes that's a bang !, for public attributes it's the dot .. Public attributes are just private attributes with a public accessor.

    class SomeClass {
        has $!a;
        has $.b;
        has $.c is rw;

        method do_stuff {
            # you can use the private name instead of the public one
            # $!b and $.b are really the same thing
            return $!a + $!b + $!c;
        }
    }
    my $x = SomeClass.new;
    say $x.a;       # ERROR!
    say $x.b;       # ok
    $x.b = 2;       # ERROR!
    $x.c = 3;       # ok

Inheritance

Inheritance is done through an is trait.

    class Foo is Bar { 
        # class Foo inherits from class Bar
        ...
    }

All the usual inheritance rules apply - methods are first looked up on the direct type, and if that fails, on the parent class (recursively). Likewise the type of a child class is conformant to that of a parent class:

        class Bar { }
        class Foo is Bar { }
        my Bar $x = Foo.new();

In this example the type of $x is Bar, and it is allowed to assign an object of type Foo to it, because "every Foo is a Bar".

Classes can inherit from multiple other classes:

    class ArrayHash is Hash is Array { 
        ...
    }

Roles and Composition

In general the world isn't hierarchical, and thus sometimes it's hard to press everything into an inheritance hierarchy. Which is one of the reasons why Perl 6 has Roles. Roles are quite similar to classes, except you can't create objects directly from them. While classes are intended primarily for type conformance, roles are the primary means for code reuse in Perl 6.

    role Paintable {
        has $.colour is rw;
        method paint { ... }
    }
    class Shape {
        method area { ... }
    }

    class Rectangle is Shape does Paintable {
        has $.width;
        has $.height;
        method area {
            $!width * $!height;
        }
    }

Contexts

2008-11-02T21:02:13+00:00

NAME

"Perl 5 to 6" Lesson 06 - Contexts

SYNOPSIS

    my @a = <a b c>
    my $x = @a;
    say $x[2];          # c
    say (~2).WHAT       # Str
    say +@a;            # 3
    if @a < 10 { say "short array"; }

DESCRIPTION

When you write something like this

    $x = @a

in Perl 5, $x contains less information than @a - it contains only the number of items in @a. To preserve all information, you have to explicitly take a reference: $x = \@a.

In Perl 6 it's the other way round: by default you don't lose anything, the scalar just stores the array. This was made possible by introducing a generic item context (called "scalar" in Perl 5) and more specialized numeric, integer and string contexts. Void and List context remain unchanged.

You can force contexts with special syntax.

    syntax      context
    ~stuff      String
    ?stuff      Bool
    +stuff      Numeric
    -stuff      Numeric (also negates)
    $( stuff )  Generic item context
    @( stuff )  List Context

Slice Context

There's also a new context called slice context. It is a list context in which lists don't interpolate.

     @( <a b> Z <c d> )     # <a c b d>
    @@( <a b> Z <c d> )     # (['a', 'c'], ['b', 'd'])

This was introduced after the observation that many built in list functions had two versions - one that returned a flat list, and one that returned a list of lists.

You can force slice context with @@( stuff ).

MOTIVATION

More specific contexts are a way to delay design choices. For example it seems premature to decide what a list should return in scalar context - a reference to the list would preserve all information, but isn't very useful in numeric comparisons. So every possible choice disappoints somebody.

With more specifc context you don't need to make this choice - it returns some sensible default, and all operators that don't like this choice can simply propagate a more specific context.

For some things like the match object the different contexts really enhance their usefulness and beauty.

A Syntax Highlighter for Perl 6

2008-11-02T21:02:06+00:00

Ahmed Zawawi implemented my idea from June 2008 and wrote a STD.pm based syntax highlighter for Perl 6.

It doesn't work very well for comments and POD (because they are parsed as whitespaces by STD.pm and thus don't appear in the parse tree at all), but apart from that it works very nicely (example here).

(The current heuristic for comments is that most of them happen at the statement_list level, so that is coloured blue, and everything else has different colours).

And it's more than a syntax highlighter: If you have javascript enabled, you can click on the "Show syntax tree" button. Then when you move the mouse over the text you'll see the length of current token and the path through the parse tree that led to it. That already helped to identify at least two mis-parses in STD.pm.

There's also a directory of syntax-highlighted test files where you can see some more output of the syntax highlighter.