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 editContent deleted Content addedVisualWikitext
Revision as of 15:10, 25 September 2006 edit152.52.0.2 (talk) →History← Previous edit Latest revision as of 16:15, 15 December 2024 edit undoCitation bot (talk | contribs)Bots5,415,417 edits Add: doi, publisher, authors 1-1. Removed parameters. Some additions/deletions were parameter name changes. Upgrade ISBN10 to 13. | Use this bot. Report bugs. | Suggested by Dominic3203 | Category:Free software programmed in C | #UCB_Category 557/633 
(874 intermediate revisions by more than 100 users not shown)
Line 1: Line 1:
{{Short description|Programming language derived from Perl}}
{{beta software}}
{{Use dmy dates|date=October 2018}}
'''Perl 6''' is the sixth major version of the ] ], currently under development.
{{Infobox programming language
| title=
| name = Raku
| logo = Camelia.svg
| logo size = 250px
| logo alt = Camelia, the Raku mascot
| logo caption = Camelia, the Raku mascot<ref name="camelia"/>
| paradigm = ]
| family = ]
| designer = ]
| developer = Raku community
| latest release version = 6.d 'Diwali'<ref>{{cite web |title=Announce: Raku Perl 6 'Diwali' 6.d Language Specification Release |publisher=Zoffix Znet |website=blogs.perl.org |date=2018-11-05 |url=http://blogs.perl.org/users/zoffix_znet/2018/11/announce-raku-perl-6-diwali-6d-language-specification-release.html |access-date=2022-08-19}}</ref>
| latest release date={{Start date and age|2020|10|24|df=yes}}
| latest preview version =
| latest preview date=
| year = {{Start date and age|2015|12|25|df=yes}}
| typing = ], ]
| scope =
| implementations = ]
| dialects =
| influenced by = ], ], ], ],<ref>{{cite web|url=http://www.perlfoundation.org/perl6/index.cgi?glossary_of_terms_and_jargon|title=Glossary of Terms and Jargon|date=2011-02-28|work=Perl Foundation Perl 6 Wiki|publisher=]|access-date=2015-02-08|archive-url=https://web.archive.org/web/20120121145808/http://www.perlfoundation.org/perl6/index.cgi?glossary_of_terms_and_jargon|archive-date=21 January 2012|url-status=dead}}</ref> ]
| influenced = ],<ref name="Tang2010">{{cite web|url=http://pugs.blogs.com/pugs/2010/04/how-to-implement-perl-6-in-10.html|title=How to Implement Perl 6 in '10|date=2010-04-21|author=唐鳳, a.k.a. ]}}</ref> ],<ref name="Tang2010"/> AntLang
| platform =
| operating system = ]
| license = ] or ]
| file extensions = .raku, .rakumod, .rakudoc, .t, .rakutest<ref>{{Cite web|title=Modules|website=docs.raku.org |url=https://docs.raku.org/language/modules#Basic_structure|access-date=2022-08-19}}</ref>
| website={{URL|raku.org}}
}}


'''Raku''' is a member of the ] family of ]s.<ref>{{cite web |url=http://www.perl.org/about.html |title=About Perl |access-date=2020-06-11 |publisher=perl.org |quote="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".}}</ref> Formerly named '''Perl 6''', it was renamed in October 2019.<ref name="renamed">{{cite web|url=https://lwn.net/Articles/802329/|title=Perl 6 renamed to Raku|publisher=]|date=15 October 2019|access-date=16 October 2019}}</ref><ref>{{cite web|url=https://news.perlfoundation.org/post/tpf-response-raku-rename|title=TPF response to Raku rename|date=29 October 2019}}</ref> Raku introduces elements of many modern and historical languages. Compatibility with Perl was not a goal, though a ] is part of the specification. The design process for Raku began in 2000.
Perl 6 is not intended to be backwards-compatible, though there will be a compatibility mode. ], the creator of Perl, has called Perl 6 "the community's rewrite of Perl", because he has based the changes largely on 361 "requests for change" submitted by the Perl community in ].<ref>{{cite web | url=http://dev.perl.org/perl6/doc/design/apo/A01.html | title=Apocalypse 1: The Ugly, the Bad, and the Good | author=] | date=April 2, 2001 }}</ref> He is outlining these changes in a series of long essays, called Apocalypses, which are numbered to correspond to chapters in '']'' ("The Camel Book"). The current, unfinalized, specification of Perl 6 is encapsulated in design documents called Synopses, which are numbered to correspond to Apocalypses.


==History== ==History==
{{Quotation|text=In Perl 6, we decided it would be better to fix the language than fix the user.|author=Larry Wall<ref>{{cite book|title=Masterminds of Programming: Conversations with the Creators of Major Programming Languages|first1=Federico|last1=Biancuzzi|first2=Shane|last2=Warden|year=2009|publisher="O'Reilly Media, Inc." |isbn=978-0596515171|url=https://books.google.com/books?id=yB1WwURwBUQC&q=%22In%20Perl%206%2C%20we%20decided%20it%20would%20be%20better%20to%20fix%20the%20language%20than%20fix%20the%20user%22}}</ref>}}
The Perl 6 design process was first announced on July 19, ], on day 4 of that year's YAPC Conference , by Larry wall in his ''State of the Onion 2000'' talk.<ref>{{cite web | title=State of the Onion 2000 | author=] | publisher=O'Reilly Network | url=http://www.perl.com/pub/a/2000/10/23/soto2000.html | year=2000}}</ref> 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.<ref>{{cite web | title=About Perl6 RFCs | author=The Perl Foundation | url=http://dev.perl.org/perl6/rfc/meta/ | year=2000}}</ref>


The Raku design process was first announced on 19 July 2000, on the fourth day of that year's ],<ref>{{cite web |title=Report from the Perl Conference |url=http://www.perl.com/pub/a/2000/08/tpc4.html |author=Kline, Joe |date=2000-08-21}}</ref> by ] in his ''] 2000'' talk.<ref>{{cite web |title=State of the Onion 2000 |last1=Wall |first1=Larry |author1-link=Larry Wall |publisher=O'Reilly Network |url=http://www.perl.com/pub/a/2000/10/23/soto2000.html |year=2000}}</ref> 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 ]s (APIs). The process began with a series of ] (RFCs). This process was open to all contributors, and left no aspect of the language closed to change.<ref>{{cite web |title=About Perl 6 RFCs |author=The Perl Foundation |url=https://raku.org/archive/rfc/meta/ |year=2000}}</ref>
Once the RFC process was complete, Wall reviewed and classified each request. He then began the process of writing the Apocalypses. While the original goal was to write one Apocolypse for each chapter of ''Programming Perl'', it became obvious that, as each Apocalypse was written, previous Apocalypses were being invaldidated 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.<ref>{{cite web | author=The Perl Foundation | title=Perl Development: Synopses | url=http://dev.perl.org/perl6/doc/synopsis.html | year=2002}}</ref>


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 ], "revealing".<ref name="apoc1">{{cite web |url=https://raku.org/archive/doc/design/apo/A01.html |title=Apocalypse 1: The Ugly, the Bad, and the Good |last1=Wall |first1=Larry |author1-link=Larry Wall |date=2001-04-02}}</ref> While the original goal was to write one Apocalypse for each chapter of '']'', 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,<ref>{{cite web |title=Raku test suite |website=] |url=https://github.com/Raku/roast |year=2019}}</ref> while the Synopses are kept as a historical reference.<ref name="syn">{{cite web |last1=Wall |first1=Larry |author1-link=Larry Wall |author2=The Perl 6 designers |title= Perl 6 Design Documents| url=https://design.raku.org/ |year=2015}}</ref>
There are three primary methods of communication used in the development of Perl 6 today. The first is the <code>#perl6</code> IRC channel on <code>irc.freenode.net</code>. The second is a set of mailing lists on ]'s servers at <code>perl.org</code>.<ref>{{cite web | title=Perl Development: Mailing Lists | author=The Perl Foundation | url=http://dev.perl.org/perl6/lists/ | year=2002}}</ref> The third is the ] source code repository used by the ] team.


There is also a series of ] written by ] 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.<ref name="exegeses">{{cite web |url=https://raku.org/archive/doc/exegesis.html |title=Exegeses |author=The Perl Foundation |year=2001}}</ref>
Over the years, Perl 6 has undergone several alterations in its direction. The introduction of concepts from ] and ] were early influences, but as the pugs interpreter was written in the ], many ] influences were absorbed by the Perl 6 design team.


There are three primary methods of communication used in the development of Raku today. The first is the Raku ] (IRC) channel on ]. The second is a set of ]s.<ref name="lists">{{cite web |title=Raku Community |author=The Raku Programming Language |url=https://raku.org/archive/lists/ |year=2022}}</ref> The third is the ] ] hosted at ].<ref>{{cite web |title=Raku |website=GitHub |url=https://github.com/raku | access-date=2022-08-19}}</ref>
==Implementations==
] is a ] designed for interpreted languages, primarily for Perl 6. The self-hosting Perl 6 compiler will target (and also run on) Parrot.


===Initial goals and implications===
Pugs is an implementation of Perl 6 in the Haskell programming language that will be used for ]. Pugs's goal is to write the Perl 6 compiler in Perl 6 itself, possibly by translating its source code to Perl 6.<ref>{{cite web | url=http://www.pugscode.org/ | title=pugscode: Pugs | author=] | year=2005 }}</ref> After that, Perl 6 will be ]&mdash;it will be used to ] itself. Much of the implementation of Perl will then be exposed, making it possible to, for example, extend the parser.
The major goal Wall suggested in his initial speech was the removal of historical warts. These included the confusion surrounding ] usage for containers, the ambiguity between the <code>select</code> functions, and the syntactic impact of bareword ]s. There were many other problems that Perl programmers had discussed fixing for years, and these were explicitly addressed by Wall in his speech.{{citation needed|date=July 2019}}


An implication of these goals was that Perl 6 would not have ] 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.
Pugs can execute Perl 6 code directly, as well as compile Perl 6 to ], ] or Parrot ].


===Mascot===
<code>]</code> is a pure Perl 5 implementation of Perl 6, making liberal use of existing ] modules, such as <code>Moose</code> and <code>Pugs::Compiler::Rule</code>. It aims to make the existing perl runtime a first-class virtual machine for both Perl 5 and Perl 6.
]
The language's ] is "Camelia, the Raku bug".<ref name="camelia">{{cite web
|url=http://www.infoworld.com/d/open-source/perl-creator-hints-imminent-release-long-awaited-perl-6-445
|title=Perl creator hints at imminent release of long-awaited Perl 6
|first=Joab
|last=Jackson
|publisher=IDG News Service
|date=23 July 2010
|access-date=2015-02-08
}}</ref>
Her name is a nod to the camel mascot associated with ], and her form, in the pun-loving tradition of the Perl community, is a play on "]". 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".<ref name="camelia-eyes">{{cite web
|url=https://irclog.perlgeek.de/perl6/2016-01-15#i_11894111
|title=Larry Wall in IRC chat log
|date=15 January 2016
|access-date=2017-11-10
}}</ref>


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.<ref name="camelia-purpose">{{cite web
== Major changes from Perl 5 ==
|url=https://github.com/perl6/mu/blob/aaa173d49c8ba681628739e96ed28fdb921211ec/misc/camelia.txt#L78-L80
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".
|title=Archived "Logo considerations" email from Larry Wall
|website=]
|date=24 March 2009
|access-date=2017-11-10
}}</ref>


==Implementations==
=== A Specification ===
{{As of|2017}}, only the ] 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."<ref name="syn01">{{cite web |url=https://design.raku.org/S01.html |title=Synopsis 1: Overview |last1=Wall |first1=Larry |author1-link=Larry Wall |date=2004-08-10}}</ref>


Rakudo Perl 6<ref>{{cite web|url=https://github.com/rakudo/rakudo/ |title=rakudo/rakudo - GitHub |publisher=Github.com |access-date=2013-09-21}}</ref><ref>{{cite web |url=http://use.perl.org/~pmichaud/journal/35400 |title=The compiler formerly known as 'perl6' |author=Michaud, Patrick |date=2008-01-16 |url-status=dead | archive-url=https://web.archive.org/web/20120218080103/http://use.perl.org/~pmichaud/journal/35400 | archive-date=2012-02-18}}</ref> targets a number of virtual machines, such as ], the ], and ]. MoarVM is a ] built especially for Rakudo<ref>{{cite web |last=Worthington |first=Jonathan |title=MoarVM: A virtual machine for NQP and Rakudo |url=http://6guts.wordpress.com/2013/05/31/moarvm-a-virtual-machine-for-nqp-and-rakudo/ |work=6guts |date=31 May 2013 |access-date=24 July 2013}}</ref> and the NQP Compiler Toolchain.<ref>{{Cite web |url=https://github.com/Raku/nqp |title=NQP - Not Quite Perl at github |website=] |date=2022-05-29 | access-date=2022-05-29}}</ref> There is a layer between Raku and the virtual machines named Not Quite Perl 6 (NQP), which implements ] for parsing Raku, and an ] and backend-specific ]. Large portions of Rakudo are written in Raku, or in its subset NQP. Rakudo is not a completely ], nor are there concrete plans at this point to make Rakudo a ].
A major, but non-technical difference between Perl 5 and Perl 6 is that Perl 6 began as a specification.<ref>{{cite web | url=http://dev.perl.org/perl6/doc/design/syn/S01.html | title=Synopsis 1: Overview | author=Wall, Larry | date=August 10, 2004 }}</ref> 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. While Perl 5's documentation was regarded as excellent, even outside of the Perl community<ref>{{cite web | url=http://xahlee.org/perl-python/perl_python_docs.html | title=Perl and Python Documentations | author=Lee, Xah | date=September 25, 2005 }}</ref>, if the documentation and the source code of the Perl 5 interpreter disagreed, the documentation would be changed.


=== A Type System === ===Historical implementations===
] was an initial implementation of Perl 6 written in ], led by ]. 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 the ] (GHC)). As of November 2014, Pugs was not being maintained.<ref>{{cite web|url=http://perl6.org/compilers/features|title=Feature comparison of Perl 6 compilers|archive-url=https://web.archive.org/web/20190207035658/https://perl6.org/compilers/features|archive-date=7 February 2019|url-status=dead}}</ref>


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.<ref name="STD">{{cite web |url=https://github.com/perl6/std/blob/master/STD.pm6 |title=Perl 6 STD |last1=Wall |first1=Larry |author1-link=Larry Wall| website=] |year=2007|display-authors=etal}}</ref><ref>{{cite web |url=http://darcs.pugscode.org/v6/v6-KindaPerl6/docs/FAQ.pod |title=mp6/kp6 FAQ |year=2006 |publisher=Perl 6 development team}}</ref> 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.
In Perl 6, the ] of Perl 5 has been augmented by the addition of static types.<ref name="syn2">{{cite web | url=http://dev.perl.org/perl6/doc/design/syn/S02.html | title=Synopsis 2: Bits and Pieces | author=Wall, Larry | date=August 10, 2004 }}</ref> 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;


Yapsi was a Perl 6 compiler and runtime written in Perl 6. As a result, it required an existing Perl 6 interpreter, such as one of the Rakudo Star releases, to run.<ref>{{cite web |url=https://github.com/masak/yapsi/blob/master/README |title=Yapsi README |website=] |year=2011}}</ref>
Static typing is beneficial for reducing subtle errors and increasing maintainability, especially in large software projects. But static typing is a burden when writing quick ]s, ]s or "one-off" code (i.e., code that is written to achieve some temporary purpose, run once and retired), purposes that have long been a mainstay of Perl. Variables which do not have an explicit type default to the mutable <code>Scalar</code> type.


Niecza, another major Perl 6 implementation effort, focused on optimization and efficient implementation research. It targets the ].<ref name="nieczareadme">{{cite web
=== Formal Subroutine Parameter Lists ===
|url=https://github.com/sorear/niecza/blob/master/README.pod
|title=Niecza README.pod
|last=O'Rear
|first=Stefan
|website=]
|date=29 November 2011
| access-date=2012-01-12
}}</ref>


==Module system==
Perl 5 defined subroutines without ] 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 <tt>@_</tt>. If <tt>@_</tt> were modified, the changes would be reflected in the original data.
The Raku specification requests that ] be identified by name, version, and authority.<ref>{{cite web |url=https://design.raku.org/S11.html |title=Synopsis 11: Modules |last1=Wall |first1=Larry |author1-link=Larry Wall |year=2004}}</ref> 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, ] to a short name is provided.


], 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>
Perl 6 introduces true formal parameters to the language.<ref name="syn6">{{cite web | url=http://dev.perl.org/perl6/doc/design/syn/S06.html | title=Synopsis 6: Subroutines | author=Wall, Larry | date=March 21, 2003 }}</ref> In Perl 6, a subroutine declaration looks like this:


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


=== Books published before Perl 6 version 1.0 (known as version 6.c) ===
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 ]) 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 should the programmer require them to be modified locally.
* {{cite book |last1=Randal |first1=Allison |last2=Sugalski |first2=Dan |last3=Tötsch |first3=Leopold |title=Perl 6 Essentials |edition=1st |publisher=O'Reilly Media |date=2003 |isbn=978-0-596-00499-6}}
* {{cite book |last1=Randal |first1=Allison |last2=Sugalski |first2=Dan |last3=Tötsch |first3=Leopold |url=http://shop.oreilly.com/product/9780596007379.do |title=Perl 6 and Parrot Essentials |edition=2nd |publisher=O'Reilly Media |date=2004 |isbn=978-0-596-00737-9}}
* {{cite book |last=Walters |first=Scott |url=http://www.apress.com/us/book/9781590593950 |title=Perl 6 Now: The Core Ideas Illustrated with Perl 5 |publisher=Expert's Voice in Open Source |date=2004-12-15 |isbn=978-1-59059-395-0}}
Also, a book dedicated to one of the first Perl 6 virtual machines, Parrot, was published in 2009.
* {{cite book |last1=Randal |first1=Allison |last2=Whitworth |first2=Andrew |url=http://onyxneon.com/books/pir/index.html |title=Parrot Developer's Guide: Pir |publisher=Onyx Neon Press |date=2009-06-15 |isbn=978-0-9779201-2-9}}


=== Books published after Perl 6 version 1.0 (known as version 6.c) ===
====Parameter passing modes====
* {{cite book |first=Andrew |last=Shitov |url=https://andrewshitov.com/perl6-at-a-glance/ |title=Perl 6 at a Glance |date=2017 |publisher=Amazon Digital Services LLC - Kdp |isbn=978-90-821568-3-6}}
Perl 6 provides three basic modes of parameter passing:
* {{cite book |last1=Rosenfeld |first1=Laurent |last2=Downey |first2=Allen B. |title=Think Perl 6 |date=2017 |publisher=O'Reilly Media |isbn=978-1-4919-8055-2 |url=http://shop.oreilly.com/product/0636920065883.do}}
* Positional
* {{cite book |last=Merelo |first=J. J. |title=Learning to program with Perl 6: First Steps: Getting into programming without leaving the command line |publisher=Learning to Program with Perl |date=2017-07-09 |isbn=978-1-5217-9578-1 |url=https://github.com/JJ/perl6em/tree/master/docs}}
* Named
* {{cite book |last=Lenz |first=Moritz |title=Perl 6 Fundamentals |publisher=Apress |date=2017-07-27 |isbn=978-1-4842-2898-2 |url=https://www.apress.com/us/book/9781484228982}}
* Slurpy
* {{cite book |last=Shitov |first=Andrew |title=Perl 6 Deep Dive |date=2017-09-07 |publisher=Packt Publishing, Limited |isbn=978-1-78728-204-9 |url=https://www.packtpub.com/application-development/perl-6-deep-dive}}
Positional parameters are the typical ordered list of parameters that most programming languages use. Named parameters may be passed in any order, and are assigned to their respective parameters based on a name tag that is associated with them. Slurpy parameters are Perl 6's tool for creating ]s.
* {{cite book |last=Shitov |first=Andrew |url=https://andrewshitov.com/using-perl6/ |title=Using Perl 6 |date=2017 |isbn=978-90-821568-1-2}}
* {{cite book |first=Gabor |last=Szabo |date=3 December 2017 |url=https://leanpub.com/bailador |title=Web Application Development in Perl 6 |publisher=Author}}
* {{cite book |last=Lenz |first=Moritz |url=https://www.apress.com/us/book/9781484232279 |title=Parsing with Perl 6 Regexes and Grammars: A Recursive Descent into Parsing |publisher=Apress |date=2017-12-04 |isbn=978-1-4842-3228-6}}
* {{cite book |last=Foy |first=Brian D. |title=Learning Perl 6 |publisher=O'Reilly Media |date=2018 |isbn=978-1-4919-7768-2 |url=http://shop.oreilly.com/product/0636920062776.do}}


=== Books published with the new Raku name ===
Here is an example of the use of all three parameter-passing modes:
* {{cite book |last=Shitov |first=Andrew |url=https://andrewshitov.com/2019/10/13/using-raku-the-free-book/ |title=Using Raku: 100 Programming Challenges Solved in the Raku Programming Language |edition=2nd |date=2019-10-13 |publisher=Suzi K Edwards |isbn=978-90-821568-8-1}}

* {{cite book |last=Shitov |first=Andrew |url=https://andrewshitov.com/2019/10/18/raku-one-liners-a-free-book/ |title=Raku One-Liners: Getting the Most of Raku's Expressive Syntax for Your Daily Routines |date=2019-10-18 |publisher=Amazon Digital Services LLC - Kdp |isbn=978-90-821568-9-8}}
sub somefunction($a, $b, :$c, :$d, *@e) {...}
* {{cite book |last=Lenz |first=Moritz |url=https://link.springer.com/book/10.1007/978-1-4842-6109-5 |title=Raku Fundamentals: A Primer with Examples, Projects, and Case Studies |publisher=Apress |date=2020-09-06 |doi=10.1007/978-1-4842-6109-5 |isbn=978-1-4842-6108-8}}
somefunction(1, 2, :d<3>, 4, 5, 6); # $a=1, $b=2, $d=3, @e=(4,5,6)
somefunction(:a<1>, :b<2>); # $a=1, $b=2

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.

=== Sigil invariance ===
In Perl 5, ]&mdash;the punctuation characters that precede a variable name&mdash;changed depending on how the variable was used:
# Perl 5 code
my <span style="color:red">@</span>array = (1, 2, 3);
my $element = <span style="color:red">$</span>array; # $element equals 2
In Perl 6, sigils are invariant<ref name="syn2"/>:
my <span style="color:red">@</span>array = (1, 2, 3);
my $element = <span style="color:red">@</span>array; # $element equals 2
This change is meant to reduce the ] of recognizing that a variable spelled <code>$array...</code> is actually the variable <code>@array</code>.

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

While extremely powerful&mdash;virtually any other computer language's object model could be simulated using this simple facility&mdash;it made the most common case of object orientation, a ]-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 for programmers who desire unusual behavior, but supplies a more robust object model for the common cases.<ref>{{cite web | url=http://dev.perl.org/perl6/doc/design/syn/S12.html | title=Synopsis 12: Objects | author=Wall, Larry | date=August 18, 2006 }}</ref> For example, a class to encapsulate a ] ] 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:
$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. ], ], and many others) that have coalesced around dot as the syntax for method invocation.

Note that the method "<code>x</code>" is not explicitly declared. This is called an auto-accessor. The "is rw" modifier on the class definition allows all of its public member attributes to be writable by default, using the auto-accessors.

==== Roles ====
Roles in Perl 6 take on the function of both ''interfaces'' in Java and ]<ref>{{cite web | title=Traits | url=http://www.iam.unibe.ch/~scg/Research/Traits/ | author=The Software Composition Group | year=2003}}</ref> in ] variant, ]. These are much like classes, but perform simple composition of classes rather than adding to their ] chain. Roles can be used to make assertions as to the interface requirements of a class, or to provide a class with behaviors.

The fundamental difference between a role and a class is that a role can never be used to define the type of an object directly, only to modify an object, class or other role.

=== Regular expressions ===
{{main|Perl 6 rules}}
Perl's ] and string-processing support has always been one of its defining features. Since Perl's pattern-matching constructs have exceeded the capabilities of ] regular expressions for some time, 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 a ], as well as acting as a ] with respect to their lexical scope.<ref>{{cite web | url=http://dev.perl.org/perl6/doc/design/syn/S05.html | title=Synopsis 5: Regexes and Rules | author=Wall, Larry | date=June 24, 2002 }}</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 5 via the <code>m</code> (matching) or <code>s</code> (search and replace) 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=http://dev.perl.org/perl6/doc/design/apo/A05.html | title=Apocalypse 5: Pattern Matching | author=Wall, Larry | date=June 4, 2002 }}</ref>

=== Syntactic simplification ===
The parentheses (round ]s) required in ] constructs in Perl 5 are now optional<ref>{{cite web | url=http://dev.perl.org/perl6/doc/design/syn/S04.html | title=Synopsis 4: Blocks and Statements | author=Wall, Larry | date=August 19, 2004 }}</ref>:

if is_true() {
for @array {
...
}
}

The three dots above (<code>...</code>) are syntactically valid in Perl 6 and are called the "yadda-yadda operator". If a running program attempts to ''execute'' "<code>...</code>", however, an ] is thrown. This operator is useful for ]s, or for marking places where the programmer intends to insert code later.

=== 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 <code>and</code> operation.

=== Lazy evaluation ===
Perl 6 uses the technique of ] of lists that has been a feature of some ] languages such as ]<ref name="syn9">{{cite web | url=http://dev.perl.org/perl6/doc/design/syn/S09.html | title=Synopsis 9: Data Structures | author=Wall, Larry | date=September 13, 2004 }}</ref>:

@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 <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 Perl 6 including input/output operations, list transformations and parameter passing.

=== Junctions ===

Perl 6 introduces the concept of ''junctions'': values that are composites of other values.<ref name="syn9"/> In the earliest days of Perl 6's design, these were called "superpositions", by analogy to the concept in ] of ]s &mdash; waveforms that can simultaneously occupy several states until observation "collapses" them. A Perl 5 module released in ] by ] called <code>Quantum::Superpositions</code><ref>{{cite web | url=http://search.cpan.org/dist/Quantum-Superpositions/lib/Quantum/Superpositions.pm | title=Quantum::Superpositions - QM-like superpositions in Perl | author=] | year=2002 }}</ref> 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 ]s:

my $even_digit = 0|2|4|6|8; # any(0, 2, 4, 6, 8)
my $odd_digits = 1&3&5&7&9; # all(1, 3, 5, 7, 9)
my $not_zero = none(0);

These values can be used in any code that would use a normal value.

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

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

====Autothreading====
Junctions are unordered; <code>1|2|3</code> and <code>3|2|1</code> 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 <code>for</code> loop should be run in parallel, possibly in separate ]. This feature is dubbed "autothreading"; its usage and implementation is not finalized and is a matter of debate in the development community.<ref>{{cite web | url=http://groups.google.com/group/perl.perl6.language/browse_frm/thread/868ab2f20deb00d8/9e7da05315e91e13?tvc=1#9e7da05315e91e13 | title=Junction Values | author=Adams, Rod | date=February 15, 2005 }}</ref>

===Macros===
In low-level languages, the concept of ]s 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}}</ref> It is this Lisp-like macro concept that Perl 6 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 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 ] representing pre-parsed code, or a combination of the two. A macro definition would look like this:

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 ] 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 ] is often used in demonstrating a programming language's most routine usage. In Perl 6, hello world can be written:

say "Hello world"

Though, ]. <code>say</code> is new to Perl 6 which prints its parameters (like the <code>print</code> function), but with a trailing ].


==References== ==References==
{{Reflist}}
<references/>

== External links ==
===Specification===
*
*
*
* . These are considered to be the official language specification.
*

===Implementations===
*
* - A current implementation of Perl 6, written in ].
* - A pure-perl implementation, based on a .
* - The main site for ] development.


===Other=== ==External links==
{{Wikibooks|Perl 6 Programming}}
* - Perl 6's blogs aggregrator.
* {{Official website}}
* - Larry Wall's talk about Perl 5 and Perl 6 at Open Source Developer Conference 2006 in ], Israel (HTML, with links to slides and audio recording)


{{Perl|state=collapsed}}
]


]
]
]
]
]
]
]
]
]
]
]
]
]
<!-- Hidden categories below -->
]

Latest revision as of 16:15, 15 December 2024

Programming language derived from Perl

Raku
Camelia, the Raku mascotCamelia, 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 or Artistic 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 named 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 application programming interfaces (APIs). The process began with a series of Request for Comments (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 Internet Relay Chat (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 named Not Quite Perl 6 (NQP), which implements Raku rules for parsing Raku, and an abstract syntax tree and backend-specific code generation. Large portions of Rakudo are written in Raku, 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, led by Audrey Tang. 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 the Glasgow Haskell Compiler (GHC)). As of November 2014, Pugs was not being 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. As a result, it required an existing Perl 6 interpreter, such as one of the Rakudo Star releases, 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. Wall, Larry; 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. Wall, Larry (10 August 2004). "Synopsis 1: Overview".
  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: