Misplaced Pages

Raku (programming language): Difference between revisions

Article snapshot taken from Wikipedia with creative commons attribution-sharealike license. Give it a read and then ask your questions in the chat. We can research this topic together.
Browse history interactively← Previous editNext edit →Content deleted Content addedVisualWikitext
Revision as of 12:12, 3 June 2024 editElseware (talk | contribs)158 edits →Sigil invariance← Previous edit Revision as of 17:46, 4 June 2024 edit undoHyperAccelerated (talk | contribs)Extended confirmed users1,553 edits Remove implementation details and examples -- Misplaced Pages is not a site for hosting documentationNext edit →
Line 99: Line 99:


], the Perl module distribution system, does not yet handle Raku modules. Instead a prototype module system is in use.<ref>{{cite web|url=https://modules.raku.org/ |title=Perl 6 Modules Directory |publisher=Modules.raku.org |access-date=2020-05-17}}</ref> ], the Perl module distribution system, does not yet handle Raku modules. Instead a prototype module system is in use.<ref>{{cite web|url=https://modules.raku.org/ |title=Perl 6 Modules Directory |publisher=Modules.raku.org |access-date=2020-05-17}}</ref>

==Major changes from Perl==
Perl and Raku differ fundamentally, though in general the intent has been to "keep Raku Perl", so that Raku is clearly "a Perl programming language". Most of the changes are intended to normalize the language, to make it easier for novice and expert programmers alike to understand, and to make "easy things easier and hard things more possible".

===A specification===
A major non-technical difference between Perl and Raku is that Raku began as a specification.<ref name="syn01">{{cite web | url=https://design.raku.org/S01.html | title=Synopsis 1: Overview | author=Wall, Larry | date=2004-08-10 }}</ref> This means that Raku can be re-implemented if needed, and it also means that programmers do not have to read the ] for the ultimate authority on any given feature. In contrast, in Perl, the official documentation is not considered authoritative and only describes the behavior of the actual Perl 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 releases.

===A type system===
In Raku, the ] of Perl has been augmented by the addition of ]s.<ref name="syn2">{{cite web | url=https://design.raku.org/S02.html | title=Synopsis 2: Bits and Pieces | author=Wall, Larry | date=2009-05-20 }}</ref> For example:
<syntaxhighlight lang="raku">
my Int $i = 0;
my Rat $r = 3.142;
my Str $s = "Hello, world";
</syntaxhighlight>
However, static typing remains ], so programmers can do most things without any explicit typing at all:
<syntaxhighlight lang="raku">
my $i = "25" + 10; # $i is 35
</syntaxhighlight>

Raku offers a ] system, whereby the programmer may choose to use static typing, use dynamic typing, or mix the two.

===Formal subroutine parameter lists===
Perl defines subroutines without ] lists at all (though simple parameter counting and some type checking can be done using Perl's "prototypes"). Subroutine arguments passed in are aliased into the elements of the array <code>@_</code>. If the elements of <code>@_</code> are modified, the changes are reflected in the original data.

Raku introduces true formal parameters to the language.<ref name="syn6">{{cite web | url=https://design.raku.org/S06.html | title=Synopsis 6: Subroutines | author=Wall, Larry | date=2003-03-21 }}</ref> In Raku, a subroutine declaration looks like this:
<syntaxhighlight lang="raku">
sub do_something(Str $thing, Int $other) {
...
}
</syntaxhighlight>
As in Perl, 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 ] so they cannot be modified. They may be declared explicitly as read-write aliases for the original value or as copies using the <code>is rw</code> or <code>is copy</code> directives respectively should the programmer require them to be modified locally.

====Parameter passing modes====
Raku provides three basic modes of parameter passing: positional parameters, ]s, and slurpy parameters.

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. Named-only parameters (indicated by a <code>:</code> before the parameter name) can only be passed by specifying its name, i.e. it never captures a positional argument. Slurpy parameters (indicated by an <code>*</code> before the parameter name) are Raku's tool for creating ]s. 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:

<syntaxhighlight lang="raku">
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)
</syntaxhighlight>

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

====Blocks and closures====
Parameters can also be passed to arbitrary blocks, which act as ]. This is how, for example, <code>for</code> and <code>while</code> 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, <code>$a, $b, $c</code>.<ref name="syn04">{{cite web | url=https://design.raku.org/S04.html | title=Synopsis 4: Blocks and Statements | author=Wall, Larry | date=2009-05-20 }}</ref>
<syntaxhighlight lang="raku">
for @list -> $a, $b, $c {
...
}
</syntaxhighlight>
This is generally referred to as a "pointy sub" or "pointy block", and the arrow behaves almost exactly like the <code>sub</code> keyword, introducing an anonymous closure (or anonymous subroutine in Perl terminology).<ref name="syn6"/>

===Sigil invariance===
In Perl, ] &ndash; the punctuation characters that precede a variable name &ndash; change depending on how the variable is used:
# Perl code
<!--Can't use tag "source lang" because of colorized emphasis on sigil-->
my {{font color|red|@}}array = ('a', 'b', 'c');
my $element = {{font color|red|$}}array; # $element equals 'b',
my @extract = {{font color|red|@}}array; # @extract equals ('b', 'c')
my $element = {{font color|red|@}}array; # 'b' comes with a warning (5.10 option)

In Raku, sigils are invariant, which means that they do not change based on whether it is the array or the array element that is needed:<ref name="syn2"/>
<!--Can't use tag "source lang" because of colorized emphasis on sigil-->
# Raku code
my {{font color|red|@}}array = 'a', 'b', 'c';
my $element = {{font color|red|@}}array; # $element equals 'b'
my @extract = {{font color|red|@}}array; # @extract equals ('b', 'c')
my @extract = {{font color|red|@}}array; # @extract equals ('b')
The variance in Perl is inspired by number agreement in English and many other natural languages:

"'''This''' apple." # $a CORRECT
"'''These''' apples." # @a CORRECT
"'''This''' third apple." # $a CORRECT
"'''These''' third apple." # @a WRONG

However, this conceptual mapping breaks down when using ], since they may refer to data structures 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:

<!-- compare the following two code blocks by using the same style syntax-->
<syntaxhighlight lang="perl">
# Perl code: retrieve a list from the leaf of a hash containing hashes that contain arrays
my @trans_verbs = @{ $dictionary{ 'verb' }{ 'transitive' } };
</syntaxhighlight>

This complexity has no equivalent either in common use of natural language or in other programming languages,{{dubious|date=October 2015}} and it causes high ] when writing code to manipulate complex data structures. This is the same code in Raku:
<syntaxhighlight lang="raku">
# Raku code: retrieve a list from the leaf of a hash containing hashes that contain arrays
my @trans_verbs = %dictionary<verb><transitive><>;
</syntaxhighlight>

===Object-oriented programming===
Perl supports ] via a mechanism known as ''blessing''. Any reference can be blessed into being an object of a particular class. A blessed object can have ]s invoked on it using the "arrow syntax" which will cause Perl to locate or "dispatch" an appropriate ] by name, and call it with the blessed variable as its first argument.

While extremely powerful, it makes the most common case of object orientation, a ]-like object with some associated code, unnecessarily difficult. In addition, because Perl can make no assumptions about the ] in use, method invocation cannot be optimized very well.

In the spirit of making the "easy things easy and hard things possible", Raku retains the blessing model and supplies a more robust object model for the common cases.<ref>{{cite web | url=https://design.raku.org/S12.html | title=Synopsis 12: Objects | author=Wall, Larry | date=2006-08-18 }}</ref> For example, a class to encapsulate a ] ] could be defined and used this way:
<syntaxhighlight lang="raku">
class Point is rw {
has $.x;
has $.y;
method distance( Point $p ) {
sqrt(($!x - $p.x) ** 2 + ($!y - $p.y) ** 2)
}
method distance-to-center {
self.distance: Point.new(x => 0, y => 0)
}
}

my $point = Point.new( x => 1.2, y => -3.7 );
say "Point's location: (", $point.x, ', ', $point.y, ')';
# OUTPUT: Point's location: (1.2, -3.7)

# Changing x and y (note methods "x" and "y" used as lvalues):
$point.x = 3;
$point.y = 4;
say "Point's location: (", $point.x, ', ', $point.y, ')';
# OUTPUT: Point's location: (3, 4)

my $other-point = Point.new(x => -5, y => 10);
$point.distance($other-point); #=> 10
$point.distance-to-center; #=> 5
</syntaxhighlight>
The dot replaces the arrow in a nod to the many other languages (e.g. ], ], ], etc.) that have coalesced around dot as the syntax for method invocation.

In the terminology of Raku, <code>$.x</code> is called an "attribute". Some languages call these ''fields ''or ''members''. The method used to access an attribute is called an "accessor". An auto-accessor method is a method created automatically and named after the attribute's name, as the method <code>x</code> is in the example above. These accessor functions return the value of the attribute. When a class or individual attribute is declared with the <code>is rw</code> modifier (short for "read/write"), the auto-accessors can be passed a new value to set the attribute to, or it can be directly assigned to as an ] (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 via the <code>$!</code> syntax regardless of how the attributes are declared. All other access must go through the accessor methods.

The Raku object system has inspired the ] framework that introduces many of Raku's OOP features to Perl.{{clarify|What does perl mean here? Perl5?|date=September 2020}}

====Inheritance, Roles and Classes====
Inheritance is the technique by which an object or type can re-use code or definitions from existing objects or types. For example, a programmer may want to have a standard type but with an extra attribute. Inheritance in other languages, such as Java, is provided by allowing Classes to be sub-classes of existing classes.

Raku provides for inheritance via Classes, which are similar to Classes in other languages, and Roles.

Roles in Raku take on the function of ], '']s'' in Ruby, and '']''<ref>{{cite web | title=Traits | url=http://www.iam.unibe.ch/~scg/Research/Traits/ | author=The Software Composition Group | year=2003 | access-date=22 September 2006 | archive-url=https://web.archive.org/web/20060811170712/http://www.iam.unibe.ch/~scg/Research/Traits/ | archive-date=11 August 2006 | url-status=dead }}</ref> in ] and in the ] variant ]. These are much like classes, but they provide a safer composition mechanism.<ref>{{cite web| title=Day 18: Roles| url=https://perl6advent.wordpress.com/2009/12/18/day-18-roles/ | year=2009 | first=Jonathan| last=Worthington}}</ref> These are used to perform composition when used with classes rather than adding to their ] 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 can be instantiated; roles are not.<ref>{{cite web | title=The Why of Perl Roles | url=http://www.modernperlbooks.com/mt/2009/04/the-why-of-perl-roles.html | author=chromatic | year=2009 | author-link=chromatic (programmer)}}</ref>

Although Roles are distinct from Classes, it is possible to write Raku code that directly instantiates a Role or uses a Role as a type object, Raku will automatically create a class with the same name as the role, making it possible to transparently use a role as if it were a class.<ref>{{Cite web|url=https://docs.raku.org/language/objects#Automatic_role_punning|title=Object orientation|website=docs.raku.org|access-date=2019-10-24}}</ref>

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, Raku will create an anonymous subclass, add the role to the subclass, and change the object's class to the anonymous subclass.

For example, a ] is a ] because dogs inherit certain characteristics from Mammals, such as ]s and (through Mammal's parent, ]) a ]. On the other hand, dogs also may have one of several distinct types of behavior, and these behaviours may change over time. For example, a Dog may be a ], a ] (an abandoned pet will acquire behaviours to survive not associated with a pet), or a ] for the blind (guide dogs are trained, so they do not start life as guide dogs). However, these are sets of additional behaviors that can be added to a Dog. It is also possible to describe these behaviors in such a way that they can be usefully applied to other animals, for example, a ] can equally be a Pet or Stray. Hence, Dog and Cat are distinct from each other, while both remain within the more general category Mammal. So Mammal is a Class and Dog and Cat are classes that inherit from Mammal. But the behaviours associated with Pet, Stray, and Guide are Roles that can be added to Classes, or objects instantiated from Classes.
<syntaxhighlight lang="raku">
class Mammal is Vertebrate {
...
}
class Dog is Mammal {
...
}
role Pet {
...
}
role Stray {
...
}
role Guide {
...
}
</syntaxhighlight>
Roles are added to a class or object with the <code>does</code> keyword. In order to show inheritance from a class, there is a different keyword <code>is</code>. 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.
<syntaxhighlight lang="raku">
class GuideDog is Dog does Guide {
...
} # Subclass composes role

my $dog = new Dog;
$dog does Guide; # Individual object composes role
</syntaxhighlight>
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 ], a Guide Human, or even a Guide Machine.
<syntaxhighlight lang="raku">
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
}
</syntaxhighlight>

===Regular expressions===
{{Main|Raku rules}}
Perl's ] and string-processing support has always been one of its defining features.<ref>{{cite web | url=http://cslibrary.stanford.edu/108/EssentialPerl.html#re | title=Essential Perl: String Processing with Regular Expressions | author=Parlante, Nick | year=2000}}</ref> Since Perl's pattern-matching constructs have exceeded the capabilities of ] expressions for some time,<ref>{{cite web | url=http://www.perl.com/doc/FMTEYEWTK/regexps.html | title=PERL5 Regular Expression Description | author=Christiansen, Tom | year=1996 | quote=Perl's regexps "aren't" -- that is, they aren't "regular" because backreferences per sed and grep are also supported, which renders the language no longer strictly regular | access-date=25 March 2010 | archive-url=https://web.archive.org/web/20100331122815/http://www.perl.com/doc/FMTEYEWTK/regexps.html | archive-date=31 March 2010 | url-status=dead }}</ref> Raku documentation exclusively refers to them as ''regexes'', distancing the term from the formal definition.

Raku provides a superset of Perl features with respect to regexes, folding them into a larger framework called "]" which provide the capabilities of ] ] formalisms (such as the ]s of ]s and ]), as well as acting as a ] with respect to their ].<ref>{{cite web | url=https://design.raku.org/S05.html | title=Synopsis 5: Regexes and Rules | author=Wall, Larry | date=2009-05-20 }}</ref> Rules are introduced with the <code>rule</code> keyword which has a usage quite similar to subroutine definition. Anonymous rules can also be introduced with the <code>regex</code> (or <code>rx</code>) keyword, or they can simply be used inline as regexps were in Perl via the <code>m</code> (matching) or <code>s</code> (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 'real' language".<ref>{{cite web | url=https://raku.org/archive/doc/design/apo/A05.html | title=Apocalypse 5: Pattern Matching | author=Wall, Larry | date=2002-06-04 }}</ref>

===Syntactic simplification===<!-- This section is linked from ] -->
Some Perl constructs have been changed in Raku, optimized for different syntactic cues for the most common cases. For example, the parentheses (round ]s) required in ] constructs in Perl are now optional:<ref name="syn04"/>
<syntaxhighlight lang="raku">
if is-true() {
for @array {
...
}
}
</syntaxhighlight>
Also, the <code>,</code> (comma) operator is now a list constructor, so enclosing parentheses are no longer required around lists. The code
<syntaxhighlight lang="raku">
@array = 1, 2, 3, 4;
</syntaxhighlight>
now makes <code>@array</code> an array with exactly the elements '1', '2', '3', and '4'.

===Chained comparisons===
Raku allows comparisons to "chain". That is, a sequence of comparisons such as the following is allowed:
<syntaxhighlight lang="raku">
if 20 <= $temperature <= 25 {
say "Room temperature is between 20 and 25!"
}
</syntaxhighlight>
This is treated as if each left-to-right comparison were performed on its own, and the result is logically combined via the <code>and</code> operation.

===Lazy evaluation===
Raku uses the technique of ] of lists that has been a feature of some ] languages such as ]:<ref name="syn9">{{cite web | url=https://design.raku.org/S09.html | title=Synopsis 9: Data Structures | author=Wall, Larry | date=2004-09-13 }}</ref>
<syntaxhighlight lang="raku">
@integers = 0..Inf; # integers from 0 to infinity
</syntaxhighlight>
The code above will not crash by attempting to assign a list of infinite size to the array <code>@integers</code>, 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 Raku including input/output operations, list transformations, and parameter passing.

===Gather===
Related to lazy evaluation is the construction of lazy lists using <code>gather</code> and <code>take</code>, behaving somewhat like generators in languages like ] or ].
<syntaxhighlight lang="raku">
my $squares = lazy gather for 0..Inf {
take $_ * $_;
};
</syntaxhighlight>
<code>$squares</code> will be an infinite list of square numbers, but lazy evaluation of the <code>gather</code> ensures that elements are only computed when they are accessed.

===Junctions===
Raku introduces the concept of ''junctions'': values that are composites of other values.<ref name="syn9"/> In their simplest form, junctions are created by combining a set of values with junctive ]s:
<syntaxhighlight lang="raku">
# Example for | ("any") Junction:
my $color = 'white';
unless $color eq 'white' | 'black' | 'gray' | 'grey' {
die "Color printing not supported\n";
}

# Example for & ("all") Junction:
my $password = 'secret!123';
if $password ~~ /<:alpha>/ & /<:digit>/ & /<:punct>/ {
say "Your password is reasonably secure";
}
</syntaxhighlight>
<code>|</code> indicates a value which is equal to either its left- ''or'' right-hand arguments. <code>&</code> 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, <code>("apple"|"banana") ~ "s"</code> would yield <code>"apples"|"bananas"</code>. In comparisons, junctions return a single true or false result for the comparison. "<code>any</code>" junctions return true if the comparison is true for any one of the elements of the junction. "<code>all</code>" 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 ] that is constrained to junctions of types:
<syntaxhighlight lang="raku">
subset Color of Any where RGB_Color | CMYK_Color;
sub get_tint(Color $color, Num $opacity) {
...
}
</syntaxhighlight>

===Macros===
In low-level languages, the concept of ] has become synonymous with textual substitution of source-code due to the widespread use of the ]. However, high-level languages such as ] pre-dated C in their use of macros that were far more powerful.<ref>{{cite book | title=Successful Lisp: How to Understand and Use Common Lisp | author=Lamkins, David B. | date=2004-12-08 | publisher=bookfix.com | url=http://psg.com/~dlamkins/sl/chapter20.html | access-date=13 September 2006 | archive-date=12 September 2006 | archive-url=https://web.archive.org/web/20060912113327/http://www.psg.com/~dlamkins/sl/chapter20.html | url-status=dead }}</ref> It is this Lisp-like macro concept that Raku will take advantage of.<ref name="syn6"/> The power of this sort of macro stems from the fact that it operates on the program as a high-level ], rather than as simple text, and has the full capabilities of the programming language at its disposal.

A Raku macro definition will look like a subroutine or method definition, and it can operate on unparsed strings, an ] representing pre-parsed code, or a combination of the two. A macro definition would look like this:<ref name="macros">{{cite web |url=https://design.raku.org/S06.html#Macros |title=Macros}}</ref>

<syntaxhighlight lang="raku">
macro hello($what) {
quasi { say "Hello { {{{$what}}} }" };
}
</syntaxhighlight>

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 ] each time it is used, many techniques of ] can be employed. It is even possible to eliminate complex computations from resulting programs by performing the work at compile-time.

===Identifiers===
In Perl, identifier names can use the ASCII alphanumerics and underscores also available in other languages. In Raku, the alphanumerics can include most Unicode characters. In addition, hyphens and apostrophes can be used (with certain restrictions, such as not being followed by a digit). Using hyphens instead of underscores to separate words in a name leads to a style of naming called "]".

==Examples==
===Hello world===
The ] is a common program used to introduce a language. In Raku, hello world is:
<syntaxhighlight lang="raku">
say 'Hello, world';
</syntaxhighlight>
&mdash; though ].

===Factorial===
The ] function in Raku, defined in a few different ways:
<syntaxhighlight lang="raku">
# Using recursion (with `if\else` construct)
sub fact( UInt $n --> UInt ) {
if $n == 0 { 1 }
else { $n * fact($n-1) }
}

# Using recursion (with `if` as statement modifier)
sub fact( UInt $n --> UInt ) {
return 1 if $n == 0;
return $n * fact($n-1);
}

# Using recursion (with `when` construct)
sub fact( UInt $n --> UInt ) {
when $n == 0 { 1 }
default { $n * fact($n-1) }
}

# Using the ternary operator
sub fact( UInt $n --> UInt ) {
$n == 0 ?? 1 !! $n * fact($n-1)
}

# Using multiple dispatch
multi fact(0) { 1 }
multi fact( UInt $n --> UInt ) {
$n * fact($n - 1)
}

# Using the reduction metaoperator
sub fact( UInt $n --> UInt ) {
1..$n
}

# Creating a factorial operator and using the reduction metaoperator
sub postfix:<!>( UInt $n --> UInt ) { 1..$n }

# Using `state` declarator to create a memoized factorial
sub fact( UInt $n --> UInt ) {
state %known = 0 => 1;
return %known{$n} if %known{$n}:exists;
%known{$n} = $n * fact($n-1);
return %known{$n};
}
</syntaxhighlight>

===Quicksort===
] is a well-known sorting algorithm. A working implementation{{efn|Unless the implementation does something fancy and mysterious behind the scenes, the maximal possible recursion depth is the length of the list, making this implementation unsuitable for big data. Recursion depth can be limited to <code>log2(list_length)</code> by iterating into the larger of partitions <code>before</code> and <code>after</code>, and only recursing into the smaller partition.}} using the functional programming paradigm can be succinctly written in Raku:
<syntaxhighlight lang="raku">
# Empty list sorts to the empty list
multi quicksort() { () }

# Otherwise, extract first item as pivot...
multi quicksort() {
# Partition.
my @before = @rest.grep(* < $pivot);
my @after = @rest.grep(* >= $pivot);

# Sort the partitions.
flat (quicksort(@before), $pivot, quicksort(@after))
}
</syntaxhighlight>

{{notelist}}

===Tower of Hanoi===
] is often used to introduce recursive programming in computer science. This implementation uses Raku's multi-dispatch mechanism and parametric constraints:
<syntaxhighlight lang="raku">
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
}
</syntaxhighlight>


== Books == == Books ==
In the history of Raku there were two waves of book writing. The first wave followed the initial announcement of Perl 6 in 2000. Those books reflect the state of the design of the language of that time, and contain mostly outdated material. The second wave, that followed the announcement of Version 1.0 in 2015, includes several books that have already been published and some others that are in the process of being written.


=== Books published before Perl 6 version 1.0 (known as version 6.c) === === Books published before Perl 6 version 1.0 (known as version 6.c) ===

Revision as of 17:46, 4 June 2024

Programming language derived from Perl
Raku
Camelia, the Raku mascot
ParadigmMulti-paradigm
FamilyPerl
Designed byLarry Wall
DeveloperRaku community
First appeared25 December 2015; 9 years ago (2015-12-25)
Stable release6.d 'Diwali' / 24 October 2020; 4 years ago (2020-10-24)
Typing disciplineDynamic, gradual
OSCross-platform
LicenseGNU General Public License or Artistic License 2
Filename extensions.raku, .rakumod, .rakudoc, .t, .rakutest
Websiteraku.org
Major implementations
Rakudo
Influenced by
Perl, Ruby, Smalltalk, Haskell, JavaScript
Influenced
Perl, Haskell, AntLang

Raku is a member of the Perl family of programming languages. Formerly known as Perl 6, it was renamed in October 2019. Raku introduces elements of many modern and historical languages. Compatibility with Perl was not a goal, though a compatibility mode is part of the specification. The design process for Raku began in 2000.

History

In Perl 6, we decided it would be better to fix the language than fix the user.

— Larry Wall

The Raku design process was first announced on 19 July 2000, on the fourth day of that year's Perl Conference, by Larry Wall in his State of the Onion 2000 talk. 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"; and 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.

Once the RFC process was complete, Wall reviewed and classified each of the 361 requests received. He then began the process of writing several "Apocalypses", using the original meaning of the term, "revealing". 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 was published, each one relating the contents of an Apocalypse, but with any subsequent changes reflected in updates. Today, the Raku specification is managed through the "roast" testing suite, while the Synopses are kept as a historical reference.

There is 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 a discussion of the usage and implications of the examples.

There are three primary methods of communication used in the development of Raku today. The first is the raku IRC channel on Libera Chat. The second is a set of mailing lists. The third is the Git source code repository hosted at GitHub.

Initial goals and implications

The major goal Wall suggested in his initial speech was the removal of historical warts. These included the confusion surrounding sigil usage for containers, the ambiguity between the select functions, and the syntactic impact of bareword filehandles. There were many other problems that Perl programmers had discussed fixing for years, and these were explicitly addressed by Wall in his speech.

An implication of these goals was that Perl 6 would not have backward compatibility with the existing Perl codebase. This meant that some code which was correctly interpreted by a Perl 5 compiler would not be accepted by a Perl 6 compiler. Since backward compatibility is a common goal when enhancing software, the breaking changes in Perl 6 had to be stated explicitly. The distinction between Perl 5 and Perl 6 became so large that eventually Perl 6 was renamed Raku.

Mascot

Larry Wall and Camelia

The language's mascot is "Camelia, the Raku bug". Her name is a nod to the camel mascot associated with Perl, and her form, in the pun-loving tradition of the Perl community, is a play on "software bug". Spiral designs embedded in her butterfly-like wings resemble the characters "P6", the favored nickname for Perl 6, and off-center eye placement is an intentional pun on "Wall-eyed".

One of the goals behind the lively and colorful design of the logo was to discourage misogyny in the community and for it to be an opportunity for those of "masculine persuasion" to show their sensitive side.

Implementations

As of 2017, only the Rakudo implementation is under active development. No implementation will be designated as the official Raku implementation; rather, "Raku is anything that passes the official test suite."

Rakudo Perl 6 targets a number of virtual machines, such as MoarVM, the Java Virtual Machine, and JavaScript. MoarVM is a virtual machine built especially for Rakudo and the NQP Compiler Toolchain. There is a layer between Raku and the virtual machines called Not Quite Perl 6, or NQP, which implements Raku rules for parsing Raku, as well as an abstract syntax tree and backend-specific code generation. Large portions of Rakudo are written in Raku itself, or in its subset NQP. Rakudo is not a completely self-hosting implementation, nor are there concrete plans at this point to make Rakudo a bootstrapping compiler.

Historical implementations

Pugs was an initial implementation of Perl 6 written in Haskell. Pugs used to be the most advanced implementation of Perl 6, but since mid 2007 it is mostly dormant (with updates made only to track the current version of GHC). As of November 2014 Pugs was not being actively maintained.

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. 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.

Yapsi was a Perl 6 compiler and runtime written in Perl 6 itself. As a result, it required an existing Perl 6 interpreter, such as one of the Rakudo Star releases, in order to run.

Niecza, another major Perl 6 implementation effort, focused on optimization and efficient implementation research. It targets the Common Language Infrastructure.

Module system

The Raku specification requests that modules be identified by name, version, and authority. It is possible to load only a specific version of a module, or even two modules of the same name that differ in version or authority. As a convenience, aliasing to a short name is provided.

CPAN, the Perl module distribution system, does not yet handle Raku modules. Instead a prototype module system is in use.

Books

Books published before Perl 6 version 1.0 (known as version 6.c)

Also, a book dedicated to one of the first Perl 6 virtual machines, Parrot, was published in 2009.

Books published after Perl 6 version 1.0 (known as version 6.c)

Books published with the new Raku name

References

  1. ^ Jackson, Joab (23 July 2010). "Perl creator hints at imminent release of long-awaited Perl 6". IDG News Service. Retrieved 8 February 2015.
  2. "Announce: Raku Perl 6 'Diwali' 6.d Language Specification Release". blogs.perl.org. Zoffix Znet. 5 November 2018. Retrieved 19 August 2022.
  3. "Modules". docs.raku.org. Retrieved 19 August 2022.
  4. "Glossary of Terms and Jargon". Perl Foundation Perl 6 Wiki. The Perl Foundation. 28 February 2011. Archived from the original on 21 January 2012. Retrieved 8 February 2015.
  5. ^ 唐鳳, a.k.a. Audrey Tang (21 April 2010). "How to Implement Perl 6 in '10".
  6. "About Perl". perl.org. Retrieved 11 June 2020. "Perl" is a family of languages, "Raku" (formerly known as "Perl 6") is part of the family, but it is a separate language which has its own development team. Its existence has no significant impact on the continuing development of "Perl".
  7. "Perl 6 renamed to Raku". LWN.net. 15 October 2019. Retrieved 16 October 2019.
  8. "TPF response to Raku rename". 29 October 2019.
  9. Biancuzzi, Federico; Warden, Shane (2009). Masterminds of Programming: Conversations with the Creators of Major Programming Languages. "O'Reilly Media, Inc.". ISBN 978-0596515171.
  10. Kline, Joe (21 August 2000). "Report from the Perl Conference".
  11. Wall, Larry (2000). "State of the Onion 2000". O'Reilly Network.
  12. The Perl Foundation (2000). "About Perl 6 RFCs".
  13. Wall, Larry (2 April 2001). "Apocalypse 1: The Ugly, the Bad, and the Good".
  14. "Raku test suite". GitHub. 2019.
  15. Larry Wall and the Perl 6 designers (2015). "Perl 6 Design Documents".{{cite web}}: CS1 maint: numeric names: authors list (link)
  16. The Perl Foundation (2001). "Exegeses".
  17. The Raku Programming Language (2022). "Raku Community".
  18. "Raku". GitHub. Retrieved 19 August 2022.
  19. "Larry Wall in IRC chat log". 15 January 2016. Retrieved 10 November 2017.
  20. "Archived "Logo considerations" email from Larry Wall". GitHub. 24 March 2009. Retrieved 10 November 2017.
  21. Cite error: The named reference syn01 was invoked but never defined (see the help page).
  22. "rakudo/rakudo - GitHub". Github.com. Retrieved 21 September 2013.
  23. Michaud, Patrick (16 January 2008). "The compiler formerly known as 'perl6'". Archived from the original on 18 February 2012.
  24. Worthington, Jonathan (31 May 2013). "MoarVM: A virtual machine for NQP and Rakudo". 6guts. Retrieved 24 July 2013.
  25. "NQP - Not Quite Perl at github". GitHub. 29 May 2022. Retrieved 29 May 2022.
  26. "Feature comparison of Perl 6 compilers". Archived from the original on 7 February 2019.
  27. Wall, Larry; et al. (2007). "Perl 6 STD". GitHub.
  28. "mp6/kp6 FAQ". Perl 6 development team. 2006.
  29. "Yapsi README". GitHub. 2011.
  30. O'Rear, Stefan (29 November 2011). "Niecza README.pod". GitHub. Retrieved 12 January 2012.
  31. Wall, Larry (2004). "Synopsis 11: Modules".
  32. "Perl 6 Modules Directory". Modules.raku.org. Retrieved 17 May 2020.

External links

Perl
Things
Frameworks
Software
Related
Books
People

Categories: