This document is intended to be used by Perl 5 programmers who are new to Perl 6 and just want a quick overview of the main differences.
More detail on everything can be found in the language reference,
which have been linked to throughout.
In certain cases,
you can also just use Perl 5 code in Perl 6 and compiler may say what's wrong.
Note that it cannot recognize every difference,
as sometimes old syntax actually means something else in Perl 6.

Note that the sigil for fetching a single element has changed from $ to @; perhaps a better way to think of it is that the sigil of a variable is now a part of its name, so it never changes in subscripting. This also applies to hashes.

The curly-bracket forms still work, but curly-brackets are more distinctly block-related now, so in fact what you've got there is a block that returns the value "February". The <> and <<>> forms are in fact just quoting mechanisms being used as subscripts (see below).

Apostrophes ' and dashes - are allowed as part of identifiers, as long as the next character is alphabetic. In other words, any two valid identifiers may be joined with a single ' or - character to form a longer identifier.

| and & as infix operators now construct junctions. The binary AND and binary OR operators are split into string and numeric operators, that is ~& is binary string AND, +& is binary numeric AND, ~| is binary string OR etc.

Was: $foo & 1;
Now: $foo +& 1;

The bitwise operators are now prefixed with a +, ~ or ? depending if the data type is a number, string or boolean.

Was: $foo << 42;
Now: $foo +< 42;

The assignment operators have been changed in a similar vein:

Was: $foo <<= 42;
Now: $foo +<= 42;

Parenthesis don't construct lists, they merely group. Lists are constructed with the comma operator. It has tighter precedence than the list assignment operator, which allows you to write lists on the right hand side without parens:

my @list = 1, 2, 3; # @list really has three elements

The arrow operator -> for dereferencing is gone. Since everything is an object, and derferencing parenthesis are just method calls with syntactic sugar, you can directly use the appropriate pair of parentheses for either indexing or method calls:

Since both builtin functions and operators are multi subs and methods, changing their behaviour for particular types is as simple as adding the appropriate multi subs and methods. If you want these to be globally available, well, you can't, because everything is lexically scoped in Perl 6. You can, however, export multi definitions to any code that wishes to import it.

If you want to write a class whose objects can be assigned to a variable with the @ sigil, you have to implement the Positional roles. Likewise, for the % sigil you need to do the Associative role. The & sigil implies Callable.

The roles provides the operators postcircumfix:<[ ]> (Positional; for array indexing), postcircumfix:<{ }> (Associative) and postcircumfix:<()> (Callable). They are technically just functions with a fancy syntax. You can override these to provide the desired semantics.

Capture objects fill the ecological niche of references in Perl 6. You can think of them as "fat" references, that is, references that can capture not only the current identity of a single object, but also the relative identities of several related objects. Conversely, you can think of Perl 5 references as a degenerate form of Capture when you want to refer only to a single item.