When it comes to embracing "embrace and extend", Perl 6 is exceptionally promiscuous in selectively borrowing from other languages (and Perl 6 is very tenacious about refining and generalizing their best ideas). Here is a brief :-) summary of some notable Perl 6 features, starting from a somewhat shorter list in another FAQ, plus a variety of additions and extensions.

((To-do wish list: It would be nice to have perhaps 3 sub-bullets for each feature giving: (1) a very brief description of it, (2) a very brief explanation of its advantages, and (3) maybe 2 or 3 minimalist examples of it. (4) relevant Perl 5 module or feature that is similar. Or maybe just link to topics about each item instead?))

Subroutines, Parameters, and Typing

• optional static type annotations (gradual typing)
• proper parameter lists
• user-defined operators
• multi dispatch
• named arguments
• generics

OO

• declarative classes with strong encapsulation
• full OO exception handling
• multi-dispatched methods (aka method overloading)
• hierarchical construction and destruction
• distributive method dispatch
• method delegation
• many widely useful objects/types
• custom meta classes, meta object programming

Regexes (now Grammars)

• LL and LR grammars (including a built-in grammar for Perl 6 itself, which is an overridable and reusable grammar)
• named regexes
• overlapping and exhaustive regex matches within a string
• named captures
• parse-tree pruning
• incremental regex matching against input streams

Power Features from Functional Languages and Elsewhere

• hypothetical variables
• hyperoperators (i.e. vector processing)
• function currying
• junctions (i.e. superpositional values, subroutines, and types)
• coroutines
• lazy evaluation (including virtual infinite lists)

Things we have in Perl 5 which will just be better in Perl 6

• better threading
• better garbage collection
• much better foreign function interface (cross-language support)
• full Unicode processing support
• string processing on various Unicode levels, including grapheme level
• a built-in switch statement

Other

(feel free to break this down into other headings)

• macros (that are implemented in Perl itself)
• user-definable operators (from the full Unicode set)
• active metadata on values, variables, subroutines, and types
• support for the concurrent use of multiple versions of a module
• extensive and powerful introspection facilities (including of POD)
• chained comparisons
• a universally accessible aliasing mechanism
• lexical exporting (via a cleaner, declarative syntax)
• multimorphic equality tests
• state variables
• invariant sigils, plus twigils (minimalist symbolic "Hungarian")

Holy freaking cow! How can most mere-mortals contend with all this stuff? Well, the good news is that you most likely won't ever need to know (or use) much of this stuff. You can learn and use a moderate and comfortable subset of Perl 6 that meets your typical needs. However these features provide an extremely powerful toolkit for experts to produce modules and other tools that you can use (without you needing to know about their internal wiring and plumbing). Perhaps counterintuitively, many of these features will make Perl 6 substantially easier and simpler than Perl 5 for more advanced applications (once you get used to it). Many of these features will also help "future-proof" Perl 6 by providing many means of incorporating new extensions.

As you can see, Perl 6 thus takes the powerful evolutionary advantages of "hybrid vigor" to new extremes. First there was "extreme programming", now we have Perl 6, "the first extreme programming language". If you think our many friends, including {Ruby, Python, Smalltalk, Lisp, Haskell, and others}, are generally more {cool, powerful, productive, and fun} than {C, C++, Java, C#}, then you'll likely recognize Perl 6 as the new "top of the food tool chain" for practical high-powered fun.