Perl 6

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken
Perl 6
Paradigma multi-paradigma
Verschenen in in ontwikkeling sinds juli 2000
Ontworpen door Larry Wall
Typesysteem dynamisch en statisch
Beïnvloed door Perl 5, Haskell, Smalltalk
Besturingssysteem Multiplatform
Licentie GNU General Public License, Artistic License
Website http://dev.perl.org/perl6/
Portaal  Portaalicoon   Informatica

Perl 6 is een versie van Perl, waaraan sinds 2000 gewerkt wordt. Perl 6 verschilt op een aantal belangrijke punten met voorgaande versies van Perl en zal niet compatibel zijn met voorgaande versies (er is echter wel een Perl 5 compatibiliteitsmode gespecificeerd als onderdeel van Perl 6[1]).

Er wordt gewerkt aan een aantal implementaties van Perl 6, voornamelijk Rakudo Perl en Pugs. Rakudo Perl is gebaseerd op Parrot, Pugs is geschreven in Haskell.

Geschiedenis[bewerken]

Perl 6 werd voor het eerst aangekondigd op 19 juli 2000[2], op de in dat jaar gehouden Perl Conference. Vervolgens begon men met een serie Request For Comments, waarbij iedereen ideeën kon aandragen.[3] Larry Wall (bedenker en ontwikkelaar van Perl) beoordeelde alle verzoeken, en schreef vervolgens een aantal Apocalypses (Nederlands: openbaringen) waarvan de eerste verscheen op 2 april 2001 en de laatste op 13 april 2004.[4]

Omdat deze Apocalypsen voortdurend onderhevig waren aan veranderingen naarmate het proces vorderde, werd er een serie Synopses (Nederlands: samenvattingen) gepubliceerd waarin de inhoud van de Apocalypsen en de latere wijzigingen hierop worden samengevat. Inmiddels zijn de Synopses op de voorgrond getreden en bevatten ze alle relevante recente informatie over de officiële Perl 6 specificaties.[5]

Er is ook een serie Exegeses (Nederlands: uitleggingen), waarin Damian Conway (een Perl developer) de inhoud van iedere Apocalyps uitlegt en de praktische implicaties van de inhoud voor de programmeur aangeeft.[6]

In 2005 begon Audrey Tang met het ontwikkelen van Pugs. Pugs is een implementatie van de Perl 6 specificatie in Haskell. Behalve dat Pugs op dit moment al gebruikt kan worden om Perl 6 code te interpreteren of te compileren, zal Pugs ook voor bootstrapping gebruikt worden. Dit houdt in dat Pugs gebruikt wordt om een Perl 6 compiler in Perl 6 te implementeren. Als dat eenmaal gebeurd is, kan Perl 6 op eigen benen staan en zichzelf compileren (de technische term hiervoor is self-hosted).

Parrot[bewerken]

Een belangrijk onderdeel van het Perl 6 platform is Parrot, een virtuele machine. Deze virtuele machine vervult een zelfde functie als de Java virtual machine, maar is toegespitst op het uitvoeren van dynamische programmeertalen en in het bijzonder Perl 6.

Parrot is een virtuele machine gebaseerd op registers (in tegenstelling tot de Java Virtuele Machine en Microsofts .NET Common Language Runtime virtuele machine die beide stackgeoriënteerd zijn). Parrot voert bytecode uit die geproduceerd wordt door een ander programma; bijvoorbeeld een assembler die Parrot assembly code vertaalt naar Parrot bytecode of een compiler die een hogere programmeertaal naar Parrot bytecode compileert. Er zijn al verschillende compilers die Perl 6 naar Parrot bytecode compileren.

Er wordt gewerkt[7] aan een aantal compilers die andere talen, waaronder Python en Scheme, naar Parrot bytecode omzetten. Op deze manier is het mogelijk om in verschillende talen applicaties te ontwikkelen die draaien in dezelfde runtime omgeving.

Veranderingen[bewerken]

Specificatie[bewerken]

Perl is (tot en met versie 5) nooit ontwikkeld op basis van een specificatie: de manier waarop de perl interpreter een programma uitvoerde is de specificatie. Dit betekent dat de source code het definitieve antwoord geeft bij twijfel over de manier waarop Perl zich hoort te gedragen. Perl 6 daarentegen is ontwikkeld op basis van een expliciete specificatie (net zoals dit bijvoorbeeld ook bij Java het geval is). Dat maakt het makkelijker om meerdere implementaties van Perl te creëren. Het betekent ook dat programmeurs niet afhankelijk zijn van de source code om erachter te komen hoe bepaalde Perl constructies zich (behoren te) gedragen.

Statische typering[bewerken]

Perl 6 kent statische typen: het is mogelijk voor de programmeur om aan te geven welk type data een variabele kan (mag) bevatten. Dit leidt tot minder programmeerfouten, beter leesbare programma's en maakt het voor de compiler mogelijk om een aantal optimalisaties toe te passen. Maar in tegenstelling tot statisch getypeerde talen, zoals C en Java, biedt Perl 6 de programmeur de mogelijkheid om zelf te kiezen, of statische en dynamische typering door elkaar te gebruiken.

Specificatie van subroutine parameters[bewerken]

Perl 6 ondersteunt formele parameters voor subroutines. In Perl 5 is het niet mogelijk om de parameters waarmee een subroutine aangeroepen kan worden (de zogenaamde type signature) te specificeren.[8]

Vaste symbolen voor variabelen[bewerken]

In Perl 5 hangt het symbool waarmee een variabele aangegeven wordt ($, @, %, etcetera) af van de manier waarop een variabele gebruikt wordt. Bijvoorbeeld: het derde element van een lijst @a, wordt genoteerd als $a[2]. In Perl 6 is dit niet langer het geval: het derde element van lijst @a wordt genoteerd als @a[2].

Objectgeoriënteerd programmeren[bewerken]

Perl 6 biedt de mogelijkheid om klassen te definiëren met behulp van een class keyword. Het objectmodel van klassen in Perl 6 biedt een aantal nieuwe mogelijkheden:[9]

In plaats van een pijl ($object->$attr), gebruikt Perl 6 een punt om attributen van objecten te noteren ($object.$attr), zoals dat ook in veel andere talen gebruikelijk is.

Roles[bewerken]

Roles (Nederlands: rollen) in Perl 6 zijn vergelijkbaar met interfaces in Java en mixins in Ruby. Het zijn een soort abstracte klassen die gebruikt worden om aanvullend gedrag van klassen te specificeren. Het verschil tussen klassen (abstract of concreet) en roles is, dat klassen geïnstantieerd kunnen worden en roles niet. In Perl 6 is het zelfs mogelijk om een role toe te voegen aan een object, en zo extra gedrag van dat object te specificeren.

Reguliere expressies en rules[bewerken]

In Perl 6 vormen rules een framework voor reguliere expressies, pattern matching en parsing in het algemeen. Omdat Perls pattern-matching-mogelijkheden verder gaan dan met formele reguliere expressies mogelijk is, worden deze in Perl 6 regexes genoemd. Deze regexes vormen een superset van Perl 5's reguliere expressies.[10]

Het rules framework van Perl 6 biedt de programmeur de mogelijkheid om grammatica's te specificeren en te parsen. Hiermee worden de mogelijkheden van Perl om met tekstuele data te werken sterk uitgebreid. De reguliere expressies van Perl 5 maken het al mogelijk om iedere lexicale constructie te herkennen, maar met de rules van Perl 6 is het ook mogelijk om grammaticale constructies in Perl zelf te specificeren en te gebruiken.

Syntaxis[bewerken]

Een aantal Perl 5 notaties zijn aangepast in Perl 6. Zo zijn bijvoorbeeld de haakjes in controlestructuren (zoals lussen en conditionele statements) niet langer verplicht:

 if is_true() {
 for @array {
 print $_;
 }
 }

De komma operator is in Perl 6 een list constructor, waardoor haakjes om lijsten ook niet langer noodzakelijk zijn:

 @lijst = 1, 2, 3, 4;

Lazy evaluation[bewerken]

Perl 6 introduceert lazy evaluation (Luie evaluatie) van lijsten. Lazy evaluation is bekend van sommige functionele programmeertalen (zoals Haskell), en houdt in dat expressies pas geëvalueerd worden als hun resultaat benodigd is. Dit maakt het bijvoorbeeld mogelijk om te werken met oneindige lijsten.

Het volgende Perl 6 fragment wijst aan de variabele @lijst de (oneindige) lijst van alle positieve integers toe en print het 3e element ervan. Hoewel deze lijst oneindig is, blijft het programma niet hangen, dankzij lazy evaluation.

 @lijst = 0..Inf;
 print @lijst[2];

En meer[bewerken]

Enkele andere nieuwe mogelijkheden in Perl 6:

  • Het gebruik van junctions. Junctions zijn superposities van meerdere waarden die zich als een enkele waarde gedragen.[11]
  • Macros. Macros in Perl 6 zijn subroutines die uitgevoerd worden op het moment dat ze geparsed worden, dus tijdens het compileren.[12]
  • Exception handling met behulp van een try { ... } CATCH { ... } constructie.[13]

Zie ook[bewerken]

Externe links[bewerken]

Bronnen, noten en/of referenties