Perl 6

From Seo Wiki - Search Engine Optimization and Programming Languages

Jump to: navigation, search
Perl 6
Paradigm Multi-paradigm
Appeared in 2000
Designed by Larry Wall
Stable release varies by implementation (Rakudo #24, December 17, 2009)
Typing discipline dynamic, static
Influenced by Perl 5, Haskell, Smalltalk
OS Cross-platform
License GNU General Public License, Artistic License

Perl 6 is a programming language specification. It serves as a major revision to Perl, introducing elements of many modern and historical languages. Perl 6 is intended to have many implementations. Backward compatibility with earlier versions of Perl is not a direct goal, though a compatibility mode is part of the specification. The design process for Perl 6 began in 2000.

Development on Pugs, the first implementation, began in 2005, and today there are multiple Perl 6 implementation projects. Rakudo Perl is based on Parrot and PGE, and releases a new version every month; as of December 2009, the project has released 24 stable versions. SMOP[1] is written in C. Larry Wall maintains a reference grammar known as, written in Perl 6 and bootstrapped with Perl 5.

The Perl 6 project has rarely promised official release dates for any implementation, although various contributors have given estimates over the years. In early 2007 Jesse Vincent, the Perl 6 Project Manager said, "The Perl 6 project has no schedule ... one doesn't want to rush a largely volunteer effort to design and implement a worthy successor to Perl 5."[2] However, the next major release of the Rakudo implementation (named "Rakudo *" or "Rakudo Star") is expected in April 2010.[3]



The Perl 6 design process was first announced on July 19, 2000, on day 4 of that year's Perl Conference,[4] by Larry Wall in his State of the Onion 2000 talk.[5] At that time, the primary goals were to remove "historical warts" from the language; "easy things should stay easy, hard things should get easier, and impossible things should get hard;" a general cleanup of the internal design and APIs. The process began with a series of requests for comments or "RFCs". This process was open to all contributors, and left no aspect of the language closed to change.[6]

Once the RFC process was complete, Wall reviewed and classified each request. He then began the process of writing several "Apocalypses", a term which means "revealing." [7] While the original goal was to write one Apocalypse for each chapter of Programming Perl, it became obvious that, as each Apocalypse was written, previous Apocalypses were being invalidated by later changes. For this reason, a set of Synopses were published, each one relating the contents of an Apocalypse, but with any subsequent changes reflected in updates. Today, Perl 6 specification continues almost entirely within the Synopses.[8]

There are also a series of Exegeses written by Damian Conway that explain the content of each Apocalypse in terms of practical usage. Each Exegesis consists of code examples along with discussion of the usage and implications of the examples.[9]

There are three primary methods of communication used in the development of Perl 6 today. The first is the #perl6 IRC channel on freenode. The second is a set of mailing lists on The Perl Foundation's servers at[10] The third is the Subversion source code repository used by the pugs team. Pugs is an early implementation of Perl 6; see the Implementations section for more detail.


The break in compatibility was mandated from the start of the project, and immediately allowed some of the changes that Larry Wall had suggested in his initial speech. "Historical warts" such as the confusion surrounding sigil usage for containers; the ambiguity between the select functions; the syntactic impact of bareword filehandles; and many other problems that Perl programmers had discussed fixing for years were some of the first issues addressed.

Over the years, Perl 6 has undergone several alterations in its direction. The introduction of concepts from Python and Ruby were early influences[citation needed], but as the Pugs interpreter was written in the Haskell programming language, many functional programming influences were absorbed by the Perl 6 design team[citation needed].


As of 2009, multiple Perl 6 implementations are under development, but none are considered "complete". As noted in the history section the language design itself is still subject to change. No implementation will be designated as the official Perl 6 implementation; rather, "Perl 6 is anything that passes the official test suite."[11]

Rakudo Perl[12][13] is a Perl 6 implementation targeting the Parrot virtual machine. Parrot is a virtual machine designed for dynamic programming languages, primarily for Perl 6. It provides several powerful compiler tools, many of which take inspiration from Perl 6. In particular, the Parrot Grammar Engine, or PGE, provides an implementation of Perl 6 grammars. As well, the language used for building compilers is itself Not Quite Perl 6, or NQP. The Rakudo implementation of Perl 6 on Parrot takes advantage of PGE and NQP. Some portions of Rakudo are written in Perl 6 itself, though this is not a self-hosting implementation, nor are there concrete plans at this point to make Rakudo a bootstrapping compiler.

Pugs is an implementation of Perl 6 written in Haskell. Pugs can execute Perl 6 code directly, and has also compiled Perl 6 to JavaScript, Perl 5 and Parrot bytecode. Due to lacking funding[citation needed], even the key developer Audrey Tang is only working part time, progress has not been as rapid as many wish. is a pure Perl 5 implementation of Perl 6, making liberal use of existing CPAN modules, such as Moose and Pugs::Compiler::Rule. It aims to make the existing perl runtime a first-class virtual machine for both Perl 5 and Perl 6.[14]

In 2007, v6-MiniPerl6 ("mp6") and its reimplementation, v6-KindaPerl6 ("kp6") were written as a means to bootstrap the Perl-6.0.0 STD, using Perl 5. The STD is a full grammar for Perl 6, and is written in Perl 6. In theory, anything capable of parsing the STD and generating executable code is a suitable bootstrapping system for Perl 6. kp6 is currently compiled by mp6 and can work with multiple backends.[15][16] mp6 and kp6 are not full Perl 6 implementations, and are designed only to implement the minimum featureset required to bootstrap a full Perl 6 compiler.

Major changes from Perl 5

Perl 5 and Perl 6 differ fundamentally, though in general the intent has been to "keep Perl 6 Perl". Most of the changes are intended to normalize the language, to make it easier for learning and expert programmers alike to understand, and to make "easy things easier and hard things more possible".

A specification

A major, but non-technical difference between Perl 5 and Perl 6 is that Perl 6 began as a specification.[17] This means that Perl 6 can be re-implemented if needed, and it also means that programmers don't have to read the source code for the ultimate authority on any given feature. Perl 5's documentation is regarded as excellent,[18] even outside of the Perl community where even mixed reviews typically note its maturity and breadth. However, since the documentation is not considered authoritative and only describes the behavior of the actual Perl 5 interpreter informally. Any discrepancies found between the documentation and the implementation may lead to either being changed to reflect the other, a dynamic which drives the continuing development and refinement of the Perl 5 releases.

A type system

In Perl 6, the dynamic type system of Perl 5 has been augmented by the addition of static types.[19] For example:

my Int $i = 0;
my Num $n = 3.142;
my Str $s = "Hello, world";

However, as with Perl 5, programmers can do most things without any explicit typing at all:

my $i = "25" + 10; # $i is 35

Perl 6 offers a hybrid typing system whereby the programmer may choose to use Static Typing, Dynamic Typing or mix the two.

Formal subroutine parameter lists

Perl 5 defined subroutines without formal parameter lists at all (though simple parameter counting and some very loose type checking can be done using Perl 5's "prototypes"). Subroutine arguments passed in were aliased into the elements of the array @_. If the elements of @_ were modified, the changes would be reflected in the original data.

Perl 6 introduces true formal parameters to the language.[20] In Perl 6, a subroutine declaration looks like this:

sub do_something(Str $thing, Int $other) { ... }

As in Perl 5, the formal parameters (i.e., the variables in the parameter list) are aliases to the actual parameters (the values passed in), but by default, the aliases are constant so they cannot be modified. They may be declared explicitly as read-write aliases for the original value or as copies using the is rw or is copy directives should the programmer require them to be modified locally.

Parameter passing modes

Perl 6 provides three basic modes of parameter passing:

  • Positional
  • Named
  • Slurpy

Positional parameters are the typical ordered list of parameters that most programming languages use. All parameters may also be passed by using their name in an unordered way. A named-only parameter can only be passed by specifying its name (that is, it never captures a positional argument), and are indicated with a leading : character. Slurpy parameters (indicated by an * before the parameter name) are Perl 6's tool for creating variadic functions. A slurpy hash will capture remaining passed-by-name parameters, whereas a slurpy array will capture remaining passed-by-position parameters.

Here is an example of the use of all three parameter-passing modes:

sub somefunction($a, $b, :$c, :$d, *@e) {...}

somefunction(1, 2, :d<3>, 4, 5, 6); # $a=1, $b=2, $d=3, @e=(4,5,6)
somefunction(:b<2>, :a<1>);         # $a=1, $b=2

Positional parameters, such as those used above are always required, unless followed by ? to indicate that they are optional. Named parameters are optional by default, but may be marked as required by adding ! after the variable name. Slurpy parameters are always optional.

Blocks and closures

Parameters can also be passed to arbitrary blocks, which act as closures. This is how, for example, for and while loop iterators are named. In the following example, a list is traversed, 3 elements at a time, and passed to the loop's block as the variables, $a, $b, $c.[21]

for @list -> $a, $b, $c { ... }

This is generally referred to as a "pointy sub" or "pointy block", and the arrow behaves almost exactly like the sub keyword, introducing an anonymous closure (or anonymous subroutine in Perl 5 terminology).[20]

Sigil invariance

In Perl 5, sigils — the punctuation characters that precede a variable name — changed depending on how the variable was used:

# Perl 5 code
my @array = ('a', 'b', 'c');
my $element = $array[1];    # $element equals 'b'
my $element = @array[1];    # in 5.10, $element equals 'b', with optional warning
my @extract = @array[1, 2]; # @extract equals ('b', 'c')

In Perl 6, sigils are invariant, which mean they do not change based on whether it is the array or the array element that is needed:[19]

# Perl 6 code
my @array = ('a', 'b', 'c');
my $element = @array[1];    # $element equals 'b'
my @extract = @array[1];    # @extract equals ('b')
my @extract = @array[1, 2]; # @extract equals ('b', 'c')

The variance in Perl 5 was inspired by number agreement in English and many other natural languages:

"This apple."                    # CORRECT
"These apples."                  # CORRECT
"This third apple."              # CORRECT
"These third apple."             # WRONG

However, this conceptual mapping breaks down when references come into play, since they may refer to containers even though they are scalars. Thus, dealing with nested data structures may require an expression of both singular and plural form in a single term:

# Perl 5 code: retrieve a list from the leaf of a hash containing hashes that contain arrays
my @trans_verb = @{ $dictionary{ 'verb' }{ 'transitive' } };

This complexity has no equivalent in common use of natural language and causes high cognitive load when writing code to manipulate complex data structures.

Object-oriented programming

Perl 5 supported object-oriented programming via a mechanism known as blessing. Any reference could be blessed into being an object of a particular class, a blessed object could have methods invoked on it using the "arrow syntax" which would cause Perl to locate or "dispatch" an appropriate subroutine by name, and call it with the blessed variable as its first argument.

While extremely powerful—virtually any other computer language's object model could be simulated using this simple facility—it made the most common case of object orientation, a struct-like object with some associated code, unnecessarily difficult. In addition, because Perl could make no assumptions about the object model in use, method invocation could not be optimized very well.

In the spirit of making the "easy things easy but hard things possible", Perl 6 retains the blessing model but supplies a more robust object model for the common cases.[22] For example, a class to encapsulate a Cartesian point could be defined and used this way:

class Point is rw {
  has $.x;
  has $.y;

my Point $point .= new( :x<1.2>, :y<-3.7> );

# Now change x (note method "x" used as lvalue):
$point.x = 2;
say "Point is at X location: ", $point.x;

The dot replaces the arrow in a nod to the many other languages (e.g. Java, Python, etc.) that have coalesced around dot as the syntax for method invocation.

In the terminology of Perl 6, $.x is called an "attribute". Some languages call these fields or members. The method used to access an attribute is called an "accessor". Auto-accessors are methods that are created automatically, as the method x is in the example above. These accessor functions return the value of the attribute. When a class or individual attribute is declared with the is rw modifier (short for "read/write"), the auto-accessor can be passed a new value to set the attribute to, or it can be directly assigned to as an lvalue (as in the example). Auto-accessors can be replaced by user-defined methods, should the programmer desire a richer interface to an attribute. Attributes can only be accessed directly from within a class definition. All other access must go through the accessor methods.


Roles in Perl 6 take on the function of interfaces in Java, mixins in Ruby, and traits[23] in the Smalltalk variant Squeak. These are much like classes, but are entirely abstract. These are used to perform composition when used with classes rather than adding to their inheritance chain. Roles define nominal types; they provide semantic names for collections of behavior and state. The fundamental difference between a role and a class is that classes are instantiable; roles are not.[24]

Essentially, a role is a bundle of (possibly abstract) methods and attributes that can be added to a class without using inheritance. A role can even be added to an individual object; in this case, Perl 6 will create an anonymous subclass, add the role to the subclass, and change the object's class to the anonymous subclass.

For example, a Dog is a Mammal. Dogs inherit certain characteristics from Mammals, such as mammary glands and (through Mammal's parent, Vertebrate) a backbone. Dogs may have one of several distinct types of behavior; for example, a Dog may be a Pet, a Stray, or a Guide for the blind. However, these are simply sets of additional behaviors that can be added to a Dog; a Cat can equally be a Pet or Stray, for example. Hence, Dog and Mammal are classes, while Pet, Stray, and Guide are roles.

class Mammal is Vertebrate {...}
class Dog is Mammal {...}
role Pet {...}
role Stray {...}
role Guide {...}

Roles are added to a class or object with the does keyword, as opposed to inheritance's is. The keywords reflect the differing meanings of the two features: role composition gives a class the behavior of the role, but doesn't indicate that it is truly the same thing as the role.

class GuideDog is Dog does Guide {...}   # Subclass composes role

my $dog = new Dog;
$dog does Guide;                         # Individual object composes role

Although roles are distinct from classes, both are types, so a role can appear in a variable declaration where one would normally put a class. For example, a Blind role for a Human could include an attribute of type Guide; this attribute could contain a Guide Dog, a Guide Horse, a Guide Human, or even a Guide Machine.

class Human {
    has Dog $dog;                        # Can contain any kind of Dog, whether it does the 
    ...                                  # Guide role or not
role Blind {
    has Guide $guide;                    # Can contain any object that does the Guide role,
    ...                                  # whether it is a Dog or something else

Perl 6 object system has inspired the Moose framework that introduces many of Perl 6 features to Perl 5.

Regular expressions

Perl's regular expression and string-processing support has always been one of its defining features.[25] Since Perl's pattern-matching constructs have exceeded the capabilities of regular language expressions for some time,[citation needed] Perl 6 documentation will exclusively refer to them as regexes, distancing the term from the formal definition.

Perl 6 provides a superset of Perl 5 features with respect to regexes, folding them into a larger framework called "rules" which provide the capabilities of context-sensitive parsing formalisms (such as the syntactic predicates of parsing expression grammars and ANTLR), as well as acting as a closure with respect to their lexical scope.[26] Rules are introduced with the rule keyword which has a usage quite similar to subroutine definition. Anonymous rules can also be introduced with the regex (or rx) keyword, or they can simply be used inline as regexps were in Perl 5 via the m (matching) or s (substitute) operators.

In Apocalypse 5, Larry Wall enumerated 20 problems with "current regex culture". Among these were that Perl's regexes were "too compact and 'cute'", had "too much reliance on too few metacharacters", "little support for named captures", "little support for grammars", and "poor integration with [the] 'real' language".[27]

Syntactic simplification

Some Perl 5 constructs have been changed in Perl 6, optimized for different syntactic cues for the most common cases. For example, the parentheses (round brackets) required in control flow constructs in Perl 5 are now optional:[21]

if is_true() {
   for @array {

Also, the , (comma) operator is now a list constructor, so enclosing parentheses are no longer required around lists. The code

@array = 1, 2, 3, 4;

now makes @array an array with exactly the elements '1', '2', '3', and '4'.

Chained comparisons

Perl 6 allows comparisons to "chain". That is, a sequence of comparisons such as the following are allowed:

if C(20) <= $temperature <= C(25) { say "Room temperature!" }

This is treated as if each left-to-right comparison were performed on its own, and the result is logically combined via the and operation.

Lazy evaluation

Perl 6 uses the technique of lazy evaluation of lists that has been a feature of some functional programming languages such as Haskell:[28]

@integers = 0..Inf; # integers from 0 to infinity

The code above will not crash by attempting to assign a list of infinite size to the array @integers, nor will it hang indefinitely in attempting to expand the list if a limited number of slots are searched.

This simplifies many common tasks in Perl 6 including input/output operations, list transformations and parameter passing.


Related to lazy evaluation is the construction of lazy lists using gather and take, behaving somewhat like generators in languages like Icon or Python.

my @squares = gather for 0..Inf {
    take $_ * $_;

@squares will be an infinite list of square numbers, but lazy evaluation of the gather ensures that elements are only computed when they are accessed.


Perl 6 introduces the concept of junctions: values that are composites of other values.[28] In the earliest days of Perl 6's design, these were called "superpositions", by analogy to the concept in quantum physics of quantum superpositions — waveforms that can simultaneously occupy several states until observation "collapses" them. A Perl 5 module released in 2000 by Damian Conway called Quantum::Superpositions[29] provided an initial proof of concept. While at first, such superpositional values seemed like merely a programmatic curiosity, over time their utility and intuitiveness became widely recognized, and junctions now occupy a central place in Perl 6's design.

In their simplest form, junctions are created by combining a set of values with junctive operators:

my $any_even_digit = 0 | 2 | 4 | 6 | 8; # any(0, 2, 4, 6, 8)
my $all_odd_digits = 1 & 3 & 5 & 7 & 9; # all(1, 3, 5, 7, 9)

| indicates a value which is equal to either its left or right-hand arguments. & indicates a value which is equal to both its left and right-hand arguments. These values can be used in any code that would use a normal value. Operations performed on a junction act on all members of the junction equally, and combine according to the junctive operator. So, ("apple"|"banana") ~ "s" would yield "apples"|"bananas". In comparisons, junctions return a single true or false result for the comparison. "any" junctions return true if the comparison is true for any one of the elements of the junction. "all" junctions return true if the comparison is true for all of the elements of the junction.

Junctions can also be used to more richly augment the type system by introducing a style of generic programming that is constrained to junctions of types:

sub get_tint ( RGB_Color|CMYK_Color $color, num $opacity) { ... }
sub store_record (Record&Storable $rec) { ... }


Junctions are unordered; 1|2|3 and 3|2|1 represent the same value. This lack of ordering means that the Perl 6 compiler can choose to evaluate junctive expressions in parallel. For instance, the code:

for all(@array) { ... }

would indicate to the compiler that the for loop should be run in parallel, possibly in separate threads. This feature is dubbed "autothreading"; its usage and implementation is not finalized and is a matter of debate in the development community.[30]


In low-level languages, the concept of macros has become synonymous with textual substitution of source-code due to the widespread use of the C preprocessor. However, high-level languages such as Lisp pre-dated C in their use of macros that were far more powerful.[31] It is this Lisp-like macro concept that Perl 6 will take advantage of.[20] The power of this sort of macro stems from the fact that it operates on the program as a high-level data structure, rather than as simple text, and has the full capabilities of the programming language at its disposal.

A Perl 6 macro definition will look like a subroutine or method definition, and can operate on unparsed strings, an AST representing pre-parsed code, or a combination of the two. A macro definition would look like this[32]:

macro hello($what) {
  q:code { say "Hello { {{{$what}}} }" };

In this particular example, the macro is no more complex than a C-style textual substitution, but because parsing of the macro parameter occurs before the macro operates on the calling code, diagnostic messages would be far more informative. However, because the body of a macro is executed at compile time each time it is used, many techniques of optimization can be employed. It is even possible to entirely eliminate complex computations from resulting programs by performing the work at compile-time.


Hello world

The hello world program is a common program used to introduce a language. In Perl 6, hello world is:

say 'Hello, world'

— though there is more than one way to do it. The say function prints its arguments (like the print function) with a trailing newline. (This feature was backported into Perl 5.10.)


Quicksort is a well-known sorting algorithm. A working implementation using the functional programming paradigm can be succinctly written in Perl 6:

sub quicksort(@list) {
    return @list if @list.elems <= 1;
    my $pivot = @list.pop;
    return (quicksort(@list.grep: { $_ <= $pivot }),
            quicksort(@list.grep: { $_ >  $pivot })

Tower of Hanoi

Tower of Hanoi is often used to introduce recursive programming in computer science. This implementation uses Perl 6's multi-dispatch mechanism and parametric constraints:

multi sub hanoi(0, $, $, $) { }                         # No disk, so do not do anything
multi sub hanoi($n, $a = 'A', $b = 'B', $c = 'C') {     # Start with $n disks and three pegs A, B, C
    hanoi($n - 1, $a, $c, $b);                          # firstly move top $n - 1 disks from A to B
    say "move disk $n from peg $a to peg $c";           # then move last disk from A to C
    hanoi($n - 1, $b, $a, $c);                          # lastly move $n - 1 disks from B to C


  1. "SMOP: Simple Meta Object Programming / Simple Matter of Programming". 2009-01-18. Retrieved 2009-08-04. 
  2. Perl 6 Project Manager (2007). "List discussion about future Perl 5 development". 
  3. Michaud, Patrick (2009-08-05). "Building a "useful release of Perl 6"". Retrieved 2009-10-27. 
  4. Kline, Joe (2000-08-21). "Report from the Perl Conference". 
  5. Wall, Larry (2000). "State of the Onion 2000". O'Reilly Network. 
  6. The Perl Foundation (2000). "About Perl 6 RFCs". 
  7. Wall, Larry (2001-04-02). "Apocalypse 1: The Ugly, the Bad, and the Good". 
  8. The Perl Foundation (2009). "Official Perl 6 Documentation". 
  9. The Perl Foundation (2001). "Exegeses". 
  10. The Perl Foundation (2002). "Perl Development: Mailing Lists". 
  11. Wall, Larry (2004-08-10). "Synopsis 1: Overview". Retrieved 2009-07-27. 
  12. [1]
  13. The compiler formerly known as "perl6" -
  14. audreyt. "Pugs 6.2.12 and released!". use Perl. 
  15. "mp6/kp6 FAQ". Perl 6 development team. 2006. 
  16. Wall, Larry, et al. (2007). "Perl 6 STD". 
  17. Wall, Larry (2004-08-10). "Synopsis 1: Overview". 
  18. Lhotsky, Brad (2004-03-10). "Thinking In Perl". 
  19. 19.0 19.1 Wall, Larry (2009-05-20). "Synopsis 2: Bits and Pieces". 
  20. 20.0 20.1 20.2 Wall, Larry (2003-03-21). "Synopsis 6: Subroutines". 
  21. 21.0 21.1 Wall, Larry (2009-05-20). "Synopsis 4: Blocks and Statements". 
  22. Wall, Larry (2006-08-18). "Synopsis 12: Objects". 
  23. The Software Composition Group (2003). "Traits". 
  24. chromatic (2009). "The Why of Perl Roles". 
  25. Parlante, Nick (2000). "Essential Perl: String Processing with Regular Expressions". 
  26. Wall, Larry (2009-05-20). "Synopsis 5: Regexes and Rules". 
  27. Wall, Larry (2002-06-04). "Apocalypse 5: Pattern Matching". 
  28. 28.0 28.1 Wall, Larry (2004-09-13). "Synopsis 9: Data Structures". 
  29. Conway, Damian (2002). "Quantum::Superpositions - QM-like superpositions in Perl". 
  30. Adams, Rod (2005-02-15). "Junction Values". 
  31. Lamkins, David B. (2004-12-08). Successful Lisp: How to Understand and Use Common Lisp. 
  32. "Macros". 

External links

Personal tools

Served in 2.118 secs.