Perl 6

Paradigma:	multiparadigma
Apareció en:	2000
Diseñado por:	Larry Wall y la comunidad Perl
Tipo de dato:	Dinámico y estático
Implementaciones:	Sitio oficial Pugs v6.pm Rakudo KindaPerl6 Not Quite Perl (NQP) Simple Meta Object Programming (SMOP)
Influido por:	Perl 5, Haskell, Smalltalk

Perl 6 es la siguiente versión del lenguaje de programación Perl, actualmente en desarrollo. La visión de Perl 6 es más que una simple reescritura de Perl 5.

Perl 6 no tiene la intención de ser compatible hacia atrás, aunque tendrá un modo de compatibilidad. Larry Wall, el creador de Perl ha llamado a Perl 6 "la reescritura de Perl por parte de la comunidad", porque ha basado los cambios en gran parte de las 361 "peticiones de cambio" enviadas por la comunidad Perl en el año 2000.^[1] Resumió estos cambios en una serie de largos ensayos llamados Apocalipsis, que están numerados para corresponder con los capítulos de Programming Perl ("El libro del Dromedario"). La actual, no acabada, especificación de Perl 6 se encuentra en los documentos de diseño llamados Sinopsis, que están numerados para corresponder con los Apocalipsis.

Perl 6 ha estado en desarrollo durante siete años, llevando a algunos comentaristas a sugerir que Perl 6 puede ser vaporware. El proyecto Perl 6 nunca ha tenido un calendario claro, aunque varios contribuyentes han dado estimaciones a lo largo de los años. A principio de 2007 Jesse, el Jefe de Proyecto de Perl 6 dijo: "El proyecto Perl 6 no tiene calendario... no queremos apresurarnos con un esfuerzo en gran parte voluntario para diseñar e implementar un sucesor digno de Perl 5."^[2]

Existe actualmente una implementación casi completa, aunque lenta, escrita en el lenguaje de programación Haskell, llamada Pugs, y existen otras dos implementaciones alternativas, una basada en Parrot y en Motor de Análisis Sintáctico (Parser Grammar Engine - PGE) y la otra en Perl 5.

Contenido 1 Historia 1.1 Objetivos 2 Implementaciones 3 Principales cambios con respecto a Perl 5 3.1 Una especificación 3.2 Un sistema tipificado 3.3 Lista formal de parámetros de subrutinas 3.3.1 Modos de pasar parámetros 3.4 Invarianza del sigil 3.5 Orientación a Objetos 3.6 Expresiones regulares 3.7 Simplificación sintáctica 3.8 Comparaciones encadenadas 3.9 Evaluación perezosa 3.10 Ensamblajes 3.11 Macros 4 Hola mundo 5 Referencias 6 Enlaces externos 6.1 Especificaciones 6.2 Implementaciones 6.3 Otros

Historia

El proceso de diseño de Perl 6 fue anunciado por primera vez el 19 de Julio del 2000, en el cuarto día de la Conferencia de Perl anual,^[3] por Larry Wall en su charla State of the Onion 2000.^[4] En ese momento, los objetivos primarios eran eliminar las "verrugas históricas" del lenguaje; "las cosas sencillas deberían continuar siendo sencillas, las cosas difíciles deberían ser más fáciles, y las cosas imposibles deberían ser difíciles"; una limpieza general del diseño interno y de los APIs. El proceso comenzó con una serie de peticiones de comentarios o "RFCs". Este proceso estuvo abierto a todos los contribuyentes, y no dejo ningún aspecto de lenguaje cerrado al cambio.^[5]

Una vez que el proceso de las RFCs se completó, Wall revisó y clasificó cada petición. Empezó entonces el proceso de escribir los Apocalípsis, cuyos nombres se refieren a la "revelación" de acuerdo con el primero de tales documentos.^[6]

El objetivo original era escribir un Apocalipsis por cada capítulo de Programming Perl, pero a medida que se iban escribiendo los Apocalipsis, se hizo obvio que los Apocalipsis previos iban siendo invalidados por los cambios posteriores. Por esta razón, se publicaron un conjunto de Sinopsis, cada una relacionada con los contenidos de un Apocalipsis, pero reflejando los cambios posteriores. Hoy, la especificación de Perl 6 continua casi de forma completa dentro de las Sinopsis.^[7]

Existen también una serie de Exegesis escritas por Damian Conway que explican los contenidos de cada Apocalipsis en términos de uso práctico. Cada Exégesis contiene ejemplos de código junto con la discusión del uso y las implicaciones de los ejemplos.^[8]

A día de hoy, hay tres métodos de comunicación usados en el desarrollo de Perl 6. El primero es el canal de IRC #perl6. El segundo es un conjunto de listas de correo en los servidores de The Perl Foundation en perl.org.^[9] El tercero es el repositorio de código fuente en Subversion usado por el equipo de pugs. Pugs es una implementación temprana de Perl 6; véase la sección acerca de Implementaciones para más detalles.

En 2008, aunque todavía está en fase de desarrollo, sin fecha de finalización planeada, ya es posible probar muchas de sus nuevas características, en cualquiera de sus implementaciones. Muchos de los desarrolladores de Perl se encuentran en la fase de aprendizaje. Incluso en CPAN ya han aparecido los primeros módulos escritos^[10] en Perl 6.

Objetivos

La ruptura en la compatibilidad era obligada desde el comienzo del proyecto, e inmediatamente permitió algunos de los cambios que Larry Wall había sugerido en su discurso inicial. "Verrugas históricas" tales como la confusión que rodea el uso del sigil para los contenedores; la ambigüedad entre las funciones de selección; el impacto sintáctico de los manejadores de fichero de palabra simple; y muchos otros problemas que los programadores de Perl habían discutido como fijar durante años fueron algunos de los primeros temas tratados.

A lo largo de los años, Perl 6 ha sufrido varias alteraciones en su dirección. La introducción de conceptos de Python y Ruby fueron influencias tempranas, pero a resultas de la escritura del intérprete Pugs en Haskell, muchas influencias de programación funcional fueron absorbidas por el equipo de diseño de Perl 6.

Implementaciones

Pugs es una implementación de Perl 6 en el lenguaje de programación Haskell que será usado como bootstrapping. La meta de Pugs es escribir el compilador de Perl 6 en el propio Perl 6, posiblemente traduciendo su código fuente a Perl 6.^[11] Después de todo, Perl 6 será autocontenido —será utilizado para compilarse a sí mismo. Mucha de la implementación de Perl estará entonces expuesta, haciendo posible, por ejemplo, extender el analizador sintáctico.

Pugs puede ejecutar código Perl 6 directamente, así como compilar Perl 6 a JavaScript, Perl 5 o bytecode de Parrot.

v6.pm es una implementación de Perl 6 en puro Perl 5, haciendo un uso liberal de actuales módulos CPAN, como el Moose y el Pugs::Compiler::Rule. Su ánimo es hacer del actual intérprete perl la principal máquina virtual tanto para Perl 5 como para Perl 6.

Parrot es una máquina virtual diseñada para lenguajes interpretados, principalmente para Perl 6. El compilador auto contenido de Perl 6 también correrá sobre Parrot.

Principales cambios con respecto a Perl 5

Perl 5 y Perl 6 difieren fundamentalmente, aunque en general la intención es la de "mantener Perl 6 como Perl". La mayor parte de los cambios están dirigidos a normalizar el lenguaje, para hacerlo más fácil de aprender, que lo entiendan los programadores expertos y hacer "cosas fáciles fácilmente y las difíciles, posibles".

Una especificación

Una principal, pero no técnica, diferencia entre Perl 5 y Perl 6 es que Perl 6 comienza como una especificación.^[12] Esto significa que si es necesario, Perl 6 puede ser reimplementado, y esto también significa que los programadores no necesitan leer el código fuente como último recurso para consultar el funcionamiento de cualquier característica. Mientras que la documentación de Perl 5 fue calificada como excelente, incluso fuera de la comunidad Perl,^[13] si la documentación y el código fuente del intérprete de Perl 5 discrepan, la documentación sería cambiada.

Un sistema tipificado

En Perl 6, el sistema de tipificado de Perl 5 ha sido aumentado con la adición de tipos estáticos.^[14] Por ejemplo:

my Int $i = 0;
my Num $n = 3.142;
my Str $s = "Hola mundo";

Sin embargo, como en Perl 5, los programadores pueden hacer la mayor parte de las cosas sin usar ninguna clase de tipificado:

my $i = "25" + 10;

El tipificado estático es beneficioso por reducir errores sutiles e incrementar la capacidad de mantenimiento, especialmente en grandes proyectos de software. Pero es una carga cuando se quiere escribir scripts, programas una-línea o código "deshechable" (es decir, código que se escribe para un propósito temporal, se ejecuta una vez y se deja), tareas que han sido un apoyo principal de Perl. Variables que no tengan un tipo explícito, por defecto serán del mutable tipo Scalar.

Lista formal de parámetros de subrutinas

Perl 5 definía subrutinas sin lista de parámetros formales (aunque un simple conteo de parámetros y un flojo chequeo de tipos pueden ser hechos con los "prototipos" de Perl 5). Los argumentos pasados a las subrutinas se convierten en alias dentro del array @_. Si @_ es modificado, los cambios se reflejan en los datos originales:

# Perl 5
sub incr { $_[0]++ }
my $x = 1;
incr($x); # $x es ahora 2
incr(3);  # error en ejecución: "Se intentó modificación de un valor de sólo lectura"

Perl 6 presenta verdaderos parámetros formales al lenguaje.^[15] En Perl 6, una declaración de subrutina se parece a algo como esto:

sub hacer_algo(Str $cosa, Int $otra) {... }

Como en Perl 5, los parámetros formales (es decir, las pseudo-variables en la lista de parámetros) son alias de los parámetros actuales (los valores pasados dentro), pero por defecto, los alias son marcados como is readonly (sólo lectura) (similar a una constante) por lo que no pueden ser modificados:

sub incr(Num $x) { 
   $x++; # error
}

Estos errores pueden ser descubiertos en tiempo de compilación, o detectados por el intérprete de Perl 6.

Sin embargo, si un parámetro formal es seguido por is copy (es copia) o is rw (es lectura y escritura), puede ser modificado. En el caso de is copy, Perl 6 copia el dato del parámetro en vez de hacer un alias, por lo que puede ser modificado, pero los cambios son locales a la subrutina. En el caso de is rw, el alias no es marcado como sólo lectura. Este cambio también captura los errores en tiempo de compilación, como el de arriba:

sub incr(Num $x is rw) { $x++ }
incr(3);                                # error en compilación (3 no puede ser modificado)
sub incr_copy(Num $x is copy) { $x++ }
incr_copy(3);                           # sin problemas

Modos de pasar parámetros

Perl 6 provee de tres modos básicos de pasar parámetros:

• Posicional
• Nombrado
• Absorbido

Parámetros posicionales se parecen a esto:

sub sumar(Int $a, Int $b) { $a + $b }
say "2+2=", sumar(2,2);

Todos los parámetros posicionales son también parámetros nombrados:

say "2+2=", sumar(:b<2>, :a<2>);

Notar que el orden no importa cuando se pasan parámetros nombrados

Los parámetros pueden ser también sólo nombrados:

sub hola(:$quien) { say "Hola, $quien" }
hola("mundo");                            # Error, debe ser nombrado
hola(:quien<"mundo">);                    # Este está bien

Parámetros absorbidos son colecciones de cero o más parámetros que se gestionan de aquellos que sobrasen después de los parámetros posicionales o nombrados:

sub say(Str *@strings) { @strings>>.print; "\n".print; }
say "¡Hola", ", ", "mundo!";

Los parámetros posicionales son requeridos(necesarios) por defecto, pero pueden hacerse opcionales añadiendo un ? después del nombre de la variable o asignándole un valor por defecto con =.

Parámetros nombrados son opcionales por defecto, pero pueden ser marcados como necesarios añadiendo ! después del nombre de la variable.

Parámetros absorbidos son siempre opcionales.

Invarianza del sigil

En Perl 5, sigils —los caracteres especiales que preceden a los nombres de variables— cambian dependiendo de cómo la variable sea usada:

# Perl 5
my @array = (0, 1, 2, 3);
my $elemento = $array[1]; # $elemento igual a 1

En Perl 6, los sigil son invariantes:

my @array = (0, 1, 2, 3);
my $elemento = @array[1]; # $elemento igual a 1

Este cambio es para reducir la carga cognitiva al intentar reconocer que la variable descrita como $array... realmente es la variable @array.

Orientación a Objetos

Perl 5 soportaba Programación orientada a objetos mediante un mecanismo conocido como bendición. Cualquier referencia puede ser bendecida para ser un objeto de una clase en particular, como por ejemplo:

# Perl 5
my $objeto = bless $referencia, 'Clase';

Un objeto bendecido puede entonces tener métodos invocados sobre él usando la "sintaxis flecha":

# Perl 5
$objeto->metodo();

que hará que Perl localice ("dispatch") una subrutina apropiada de nombre metodo y llamarla con el $objeto como primer argumento.

Mientras que es extremadamente potente —virtualmente, cualquier modelo de objetos en lenguajes de ordenador puede ser simulado usando esta simple técnica— hace que la implementación más común de la orientación a objetos —un objeto parecido a una estructura de datos con algo de código asociado—, innecesariamente difícil. Además, como Perl no hace suposiciones sobre el modelo de objeto en uso, la invocación de métodos no puede quedar bien optimizada.

En el espíritu de hacer "las cosas sencillas simples y las difíciles, posibles", Perl 6 mantiene el modelo de bendición para los programadores que desean este inusual comportamiento, pero suple un modelo de objeto más robusto en la mayoría de los casos.^[16] Por ejemplo, una clase para encapsular un punto en un sistema de coordenadas cartesianas puede ser escrito como:

class Punto is rw {
  has $.x;
  has $.y;
}

y utilizado como:

my Punto $punto.= new;
$punto.x = 1.2;
$punto.y = -3.7;

El punto reemplaza a la flecha como un gesto a muchos otros lenguajes, por ejemplo C++, Java, Python y Ruby, que acordaron el uso del punto como la sintaxis para la invocación de métodos.

Nótese que los métodos "x" e "y" no están explícitamente declarados. Se llaman auto-acceso. El modificador "is rw" en la definición de la clase permite, por defecto, que todos los atributos de sus miembros públicos sean escribibles usando los auto-acceso.

Los atributos pueden ser declarados de la siguientes maneras:

has $.a;       # Usar modo de acceso por defecto (normalmente sólo lectura)
has $.b is rw; # Acceso Lectura/Escritura
has $!c;       # No acceso público (privado)
has $d;        # Lo mismo que $!d

Expresiones regulares

Las expresiones regulares y el procesado de texto de Perl han sido siempre unas de sus características definitorias. Al contrario que otros lenguajes, en que se puede trabajar con las expresiones regulares con la ayuda de una biblioteca, Perl incorpora el ajuste de patrones en el propio lenguaje. Debido a que las construcciones de emparejamiento de patrones han excedido las capacidades de las expresiones regulares de los lenguajes formales durante algún tiempo, la documentación de Perl 6 se referirá a ellas exclusivamente como regexes (contractura inglesa de 'regular' y 'expression'), distanciándose del término empleado en la definición formal.

Perl 6 ofrece un superconjunto de las posibilidades de Perl 5 con respecto a las regexes, incluyéndolas en un gran cuadro de trabajo llamado "reglas" (rules, (en inglés)) que ofrece las posibilidades de parseado de expresiones gramaticales, así como actuar como closura con respecto a su ámbito léxico.^[17] Las Reglas se presentan con la palabra clave rule que tiene un uso muy similar a la definición de subrutinas. Reglas anónimas pueden ser definidas con la palabra clave regex (o rx), o pueden simplemente usarse incluidas como las expresiones regulares donde en Perl 5 se usarían los operadores m (coincidencia o emparejamiento) o s (búsqueda y reemplazamiento).

En el Apocalipsis 5, Larry Wall enumeró los 20 problemas de la "actual cultura regex". Aparte de que las expresiones regulares de Perl fueran "demasiado compactas y 'lindas'", tenían "demasiada confianza en muy pocos meta-caracteres", "pequeño soporte para capturas con nombre", "pequeño soporte para gramáticas" y "pobre integración con el lenguaje [real]".^[18]

Sólo hay seis características que no han cambiado de las regexes de Perl 5:

• Literales: caracteres alfanuméricos como "A" y el guión bajo serán emparejados literalmente.
• Capturando: (...)
• Alternativas: |
• Escape con la contra barra: \
• Cuantificadores de repetición: *, + y ?
• Sufijo de emparejamiento mínimo: *?, +?, ??

Algunas de las adiciones más poderosas incluyen:

• La habilidad de referencias a reglas usando <nombre de regla> para construir gramáticas enteras.
• Un puñado de operadores de confianza que permite al programador controlar la vuelta atrás (backtracking) durante el emparejamiento.

Los siguientes cambios aumentan notablemente la legibilidad de las regexes:

• Simplificación de los grupos de no-captura: [...] que son los mismos que el (?:...) en Perl 5
• Código simplificado para las aserciones: <?{...}>
• El /x de Perl 5 está siempre activo por defecto.

Ejemplos:

rx { a [ b | c ] ( d | e ) f : g }
rx { ?( ab* ) <{ $1.size % 2 == 0 }> }

Este último es idéntico a:

rx { ( ab[bb]* ) }

Simplificación sintáctica

Los paréntesis requeridos en las estructuras de control de Perl 5 ahora son opcionales:^[19]

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

Los puntos suspensivos de arriba (...) son sintácticamente válidos en Perl 6 y son llamados el "operador bla-bla-bla". Sin embargo, si un programa intenta ejecutar "...", se lanza una excepción. Este operador es útil para los métodos abstractos, o para reservar lugares donde el programador tiene la intención de insertar código más adelante.

Comparaciones encadenadas

Los nuevos programadores esperan que encadenando comparaciones como lo siguiente, funcione:

if 1 <= $dado1 == $dado2 <= 6 { say "¡Dobles!" }

En Perl 6, este código funciona como se espera, dentro del espíritu de DWIM (Do What I Mean. Haz lo que digo) y es ejecutado como si se hubiera escrito:

if 1 <= $dado1 and $dado1 == $dado2 and $dado2 <= 6 { say "¡Dobles!" }

Evaluación perezosa

Perl 6 aumenta la evaluación perezosa de listas que ha sido una característica de algunos lenguajes de la programación funcional como el lenguaje Haskell:^[20]

my int @enteros = 0..Inf; # enteros desde 0 al infinito
for @enteros -> $contador {
  say "$contador";
  last if $contador >= 10;
}

Este código no caerá intentando asignar una lista de tamaño infinito al array @enteros, ni se quedará colgado indefinidamente intentando expandir la lista en el bucle for. En lugar de eso, imprimirá la lista de enteros desde 0 a 10 y continuará.

Debido a este comportamiento, el bien conocido modismo de Perl de leer de la lista de argumentos de la entrada estándar:

# Perl 5
while (<>) {
  print;
}

es reemplazada por

# Perl 6
for =<> {
  print;
}

El operador prefijo = convierte un manejador de fichero o nombre de fichero en un iterador.

Esto ya no será un modismo, porque, a diferencia del código en Perl 5, que automágicamente era expandido en

# Perl 5
while (defined ($_ = <>)) {
  print;
}

la evaluación perezosa de Perl 6 de for (junto con una regla de terminación de lista de entrada <> al fin de fichero) significa que el bucle for en Perl 6 arriba escrito no está sujeto a ninguna conversión especial para funcionar como se espera.

Ensamblajes

Perl 6 introduce el concepto de ensamblajes (junctions): valores que son compuestos de otros valores.^[20] En los primeros días del diseño de Perl 6, se les llamó "superposiciones", por analogía con el concepto superposición cuántica de la Mecánica cuántica —formas de onda que simultáneamente ocupan varios estados hasta que el observador los "colapsa". Un módulo Perl 5 lanzado en el 2000 por Damian Conway llamado Quantum::Superpositions^[21] ofrece una inicial prueba de concepto. Mientras que al principio, valores superpuestos parecen meramente como una curiosidad de la programación, con el tiempo se ha reconocido su utilidad e intuición siendo ampliamente reconocido y las ensambladuras ahora ocupan un lugar central en el diseño de Perl 6.

En su forma más simple, los ensamblajes son creadas combinando un conjunto de valores con los operadores de yuxtaposición:

my $digito_par    = 0|2|4|6|8; # any(0, 2, 4, 6, 8)
my $digitos_impar = 1&3&5&7&9; # all(1, 3, 5, 7, 9)
my $no_cero = none(0);

Estos valores pueden ser usados aritméticamente:

my $ensamblaje = 1|2|3;
$ensamblaje   += 4;     # el ensamblaje ahora es igual a 5|6|7
$ensamblaje   += (1&2); # el ensamblaje ahora es igual a (6|7|8)&(7|8|9)

o en comparaciones:

if $nota eq any('5'..'10') { say "aprobado" }

o incluso en subíndices:

if %persona{any('nombre','nick')} eq "Juan" { say "¿Qué es lo que sabes, Juan?" }

Los ensamblajes pueden ser usados también para enriquecer el sistema de tipificado:

class RGB_Color is Tupla[int,3] & Color {... }
sub coger_tinte (RGB_Color|CMYK_Color $color, num $opacidad where 0 <= $^opacidad <= 1) {... }
sub registro_inventario (Registro&Inventario $rec) {... }

Los ensamblajes están desordenados; 1|2|3 y 3|2|1 representan el mismo valor. Esta falta de ordenación significa que el compilador de Perl 6 puede elegir evaluar expresiones de ensamblajes en paralelo. Por ejemplo, el código

for all(@array) {... }

indicará al compilador que el bucle for debe correr en paralelo, posiblemente en hilos separados. Esta característica se llama autothreading; su uso e implementación no está finalizada y es materia de debate en la comunidad de desarrollo.^[22]

Macros

En lenguajes de bajo nivel, el concepto de macro ha llegado a ser sinónimo de sustitución de texto en el código fuente debido al amplio uso del preprocesador de C. En cambio, los lenguajes de alto nivel como Lisp anteceden a C en el uso de macros y de forma mucho más poderosa.^[23] Perl 6 se aprovechará de este concepto de macro del Lisp.^[15] El poder de esta forma de macros deriva del hecho de que opera en el programa como una estructura de datos de alto nivel, en lugar de ser un texto simple, y con todas las capacidades del lenguaje de programación a su disposición.

Una definición de macro en Perl 6 se parecerá a una definición de una subrutina o método y puede operar sobre: strings no parseadas, un árbol sintáctico representando código pre-parseado, o una combinación de los dos. Una definición de macro se parecería a esto:

macro hola($que) {
  q:code { say "Hola { {{{$que}}} }" };
}

En este ejemplo en particular, la macro no es más compleja que una sustitución al estilo del C, pero como el parseo del parámetro de la macro ocurre antes de que la macro opere sobre el código que la llama, los mensajes de diagnóstico serán mucho más informativos. En cambio, debido a que el cuerpo de la macro se ejecuta en tiempo de compilación cada vez que se la usa, se pueden emplear muchas técnicas de optimización. Es incluso posible eliminar enteramente cálculos complejos de los programas resultantes realizando el trabajo durante el tiempo de compilación.

Hola mundo

El programa hola mundo en Perl 6 se puede escribir como

say "Hola mundo"

aunque en Perl "hay más de una forma de hacerlo". say es nuevo en Perl 6, e imprime sus parámetros (como la función print), pero añadiendo un carácter de nueva línea. En Perl 5, Se habría definido como:

sub say {
  print @_, "\n";
}

Referencias

1. ↑ Larry Wall. «Apocalypse 1: The Ugly, the Bad, and the Good». Consultado el 2001-04-02. (en inglés)
2. ↑ Perl 6 Project Manager (2007). «List discussion about future Perl 5 development».
3. ↑ Kline, Joe (2000-08-21). «Report from the Perl Conference».
4. ↑ Wall, Larry (2000). «State of the Onion 2000». O'Reilly Network.
5. ↑ The Perl Foundation (2000). «About Perl6 RFCs».
6. ↑ Wall, Larry (2001-04-02). «Apocalypse 1: The Ugly, the Bad, and the Good».
7. ↑ The Perl Foundation (2002). «Perl Development: Synopses».
8. ↑ The Perl Foundation (2001). «Exegeses».
9. ↑ The Perl Foundation (2002). «Perl Development: Mailing Lists».
10. ↑ gugod. «Módulo JavaScript::Writer». Consultado el 2008-02-09. (en inglés)
11. ↑ Audrey Tang (2005). «pugscode: Pugs». (en inglés)
12. ↑ Larry Wall. «Synopsis 1: Overview». Consultado el 2004-08-10. (en inglés)
13. ↑ Xah Lee. «Perl and Python Documentations». Consultado el 2005-09-25. (en inglés)
14. ↑ Larry Wall. «Synopsis 2: Bits and Pieces». Consultado el 2004-08-10. (en inglés)
15. ↑ ^{a b} Larry Wall. «Synopsis 6: Subroutines». Consultado el 2003-03-21. (en inglés)
16. ↑ Larry Wall. «Synopsis 12: Objects». (en inglés)
17. ↑ Larry Wall. «Synopsis 5: Regexes and Rules». Consultado el 2002-06-24. (en inglés)
18. ↑ Larry Wall. «Apocalypse 5: Pattern Matching». Consultado el 2002-06-04. (en inglés)
19. ↑ Larry Wall. «Synopsis 4: Blocks and Statements». Consultado el 2004-08-19. (en inglés)
20. ↑ ^{a b} Larry Wall. «Synopsis 9: Data Structures». Consultado el 2004-09-13. (en inglés)
21. ↑ Damian Conway. «Quantum::Superpositions - QM-like superpositions in Perl». (en inglés)
22. ↑ Rod Adams. «Junction Values». Consultado el 2005-02-15. (en inglés)
23. ↑ Lamkins, David B. (2004-12-08). bookfix.com (ed.). Successful Lisp: How to Understand and Use Common Lisp. (en inglés)

Enlaces externos

Especificaciones

• La comunidad original de los RFC (en inglés)
• Apocalipsis - El primer pase de Larry sobre los borradores (en inglés)
• Exégesis - Detallada explicación de cada Apocalipsis con códigos de ejemplo (en inglés)
• Sinopsis - El resumen desarrollado de cada Apocalipsis, actualizado regularmente. Se considera a éstos como la especificación oficial del lenguaje. (en inglés)
• Documentación oficial de Perl 6 (en inglés)

Implementaciones

• El sitio oficial de desarrollo de Perl 6 (en inglés)
• Pugs - Una implementación de Perl 6, escrita en Haskell (en inglés)
• v6.pm - Una implementación escrito en puro perl, basado en los módulos Perl 6 en CPAN (en inglés)
• Rakudo - Perl 6 sobre Parrot (en inglés)
• parrotcode - El sitio principal de desarrollo de la máquina virtual Parrot (en inglés)
• KindaPerl6 - Un subconjunto de Perl 6 sobre Perl 5 (en inglés)
• Not Quite Perl (NQP) - Un compilador de rutinas en formato PIR a partir de código similar a Perl 6 (en inglés)
• Simple Meta Object Programming (SMOP) - Intérprete de Perl 6 escrito en C (en inglés)

Otros

• Agregador de blogs sobre Perl 6 (en inglés)
• Presente Continuo, Futuro Perfecto - Charla de Larry Wall sobre Perl 5 y Perl 6 en la Open Source Developer Conference 2006 en Netanya, Israel (HTML, con enlaces a la presentación y audición sonora) (en inglés)
• Perl 6 FAQ (en inglés)
• Perl6::Perl5::Differences (en inglés)