Perl 6

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Perl 6
Camelia.svg
Camelia, la mascota de Perl 6[1]
Desarrollador(es)
Comunidad Perl
perl6.org
Información general
Extensiones comunes .pl, .pm, .pod
Paradigma multiparadigma: orientado a objetos, imperativo, funcional, reflexivo
Apareció en 19 de julio de 2000; hace 14 años (2000-07-19)
Diseñado por Larry Wall
Última versión estable (varía según la implementación)
Rakudo Star / 7 de febrero de 2015; hace 50 días (2015-02-07)[2]
Niecza Perl 6 / 26 de marzo de 2013; hace 2 años (2013-03-26)[3]
Tipo de dato dinámico, estático, gradual
Implementaciones Rakudo Star, Niecza
Influido por Haskell,[4] JavaScript, Perl 5, Ruby, Smalltalk
Sistema operativo Multiplataforma
Licencia GPL o Licencia Artística
[editar datos en Wikidata]

Perl 6 es un miembro de la familia de lenguajes de programación Perl.[5] Todavía está en desarrollo, como una especificación sobre la que se han escrito varios intérpretes y compiladores. Está incorporando elementos de muchos lenguajes modernos e históricos. Perl 6 está destinado a tener muchas implementaciones. La compatibilidad con versiones anteriores de Perl no es un objetivo directo, aunque un modo de compatibilidad es parte de la especificación. El proceso de diseño de Perl 6 comenzó en el 2000. Se espera un intento de lanzamiento en septiembre de 2015 y un lanzamiento final en diciembre.[6]

El desarrollo de Pugs, la primera implementación con mayor empuje, comenzó en el 2005, y hoy existen múltiples proyectos de implementación de Perl 6. Rakudo Perl 6 se basó en y NQP (Not Quite Perl) y puede usar MoarVM, la máquina virtual Java o Parrot como entorno de ejecución, y aparecen nuevas versiones cada mes. En julio de 2010, el proyecto lanzó la primera distribución Rakudo Star,[7] una colección de útiles y materiales relacionados, de una implementación de Perl 6. Larry Wall mantiene una referencia de la gramática conocida como STD.pm, escrita en Perl 6 y ejecutada con Perl 5.

Niecza, otra principal implementación de Perl 6, se centra en la investigación de la optimización e implementación eficiente. Se dirige al Common Language Infrastructure.[8]

Historia[editar]

En Perl 6, decidimos que sería mejor arreglar el lenguaje que arreglar al usuario

Larry Wall

El proceso de diseño de Perl 6 se anunció por primera vez el 19 de julio de 2000, en el cuarto día de la Conferencia Perl anual,[9] por Larry Wall, en su charla State of the Onion 2000.[10] 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 la API. El proceso comenzó con una serie de peticiones de comentarios o "RFC". Este proceso estuvo abierto a todos los contribuyentes, y no dejó ningún aspecto del lenguaje cerrado al cambio.[11]

Una vez que el proceso de las RFC se completó, Wall revisó y clasificó cada petición. Empezó entonces el proceso de escribir los "Apocalipsis", un término que se refiere a la "revelación".[12] Mientras que el objetivo original era escribir un Apocalipsis por cada capítulo de Programming Perl, a medida que se iba escribiendo cada uno, se hizo obvio que los cambios previos iban siendo invalidados por los 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.[13]

Existen también una serie de Exégesis 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.[14]

A día de hoy, se usan tres métodos de comunicación 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.[15] El tercero es el repositorio de código fuente Git alojado en https://github.com/perl6.

Objetivos[editar]

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 sigilo (sigil) para los contenedores; la ambigüedad entre las funciones select; el impacto sintáctico de los gestores de fichero de una palabra simple; y muchos otros problemas que los programadores de Perl habían discutido cómo arreglar 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. De forma temprana se introdujeron conceptos desde Python y Ruby, pero a resultas de la escritura del intérprete Pugs en el lenguaje de programación Haskell, muchas influencias de la programación funcional fueron absorbidas por el equipo de diseño de Perl 6.

Mascota[editar]

Larry Wall y Camelia

El nombre de la mascota es "Camelia, el bicho de Perl 6".[1] Su nombre es una referencia a la mascota del dromedario asociado a Perl, y su forma, siguiendo la tradición amorosa de la comunidad Perl, es una reproducción de un "error de software". Diseños simétricos incrustados en sus alas recuerdan las letras "P6", la abreviatura de Perl 6.

Implementaciones[editar]

En 2015, solo la implementación Rakudo Perl está bajo desarrollo activo. Ninguna implementación se designará como la oficial de Perl 6; en su lugar, "Perl 6 será cualquier cosa que pase el conjunto de test oficial".[16]

Rakudo Perl[17] [18] es una implementación de Perl 6 para diversas máquinas virtuales, como MoarVM, la máquina virtual Java y Javascript. MoarVM es una máquina virtual diseñada para lenguajes de programación dinámicos, principalmente para Perl 6. Existe una capa entre Perl 6 y las máquinas virtuales, llamada Not Quite Perl 6, o NQP, que implementa las reglas de Perl 6 para la interpretación de Perl 6, así como el Árbol de sintaxis abstracta y la Generación de código específico de la arquitectura. La mayor parte de Rakudo se ha escrito en el mismo Perl 6, aunque no se trate de una implementación auto contenida, ni existan planes concretos, en este punto, para que Rakudo sea un compilador completo y autosuficiente.

Implementaciones históricas[editar]

Pugs fue una implementación de Perl 6 escrita en el lenguaje de programación Haskell. Pugs se utilizaba como la implementación más avanzada de Perl 6, pero desde mediados del 2007 está prácticamente dormido (solo han aparecido actualizaciones para las nuevas versiones de GHC, desde entonces). Desde noviembre de 2014, Pugs ya no recibe mantenimiento.[19]

En 2007, v6-MiniPerl6 ("mp6") y su reimplementación, v6-KindaPerl6 ("kp6") se escribieron como un medio para arrancar el Perl-6.0.0 STD, usando Perl 5. El STD es una gramática completa para Perl 6, y está escrito en Perl 6. En teoría, cualquier cosa capaz de analizar el STD y generar el código ejecutable es un adecuado sistema de arranque para Perl 6. kp6 está actualmente compilado por mp6 y puede trabajar con múltiples entornos finales.[20] [21] mp6 y kp6 no son implementaciones completas de Perl 6, y están diseñadas solo para implementar el conjunto de características mínimas para arrancar un completo compilador de Perl 6.

Yapsi es un compilador e intérprete de Perl 6 escrito en el propio Perl 6. De resultas de esto, requiere de la existencia de un intérprete de Perl 6, como el de Rakudo Star, para poder ejecutarse.[22]

Sistema de módulos[editar]

La especificación de Perl 6 solicita que los módulos queden identificados por nombre, versión y autoría.[23] Es posible cargar sólo una versión específica de un módulo, o incluso dos módulos del mismo nombre que se diferencian en la versión o la autoría. Por comodidad, su puede indicar un nombre corto como un alias del módulo.

CPAN, el sistema de distribución de módulos de Perl 5, todavía no maneja módulos Perl 6. En su lugar, se usa un prototipo de un sistema de módulos.[24]

Principales cambios con respecto a Perl 5[editar]

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 entender para los programadores novatos y expertos, y hacer "las cosas fáciles más fácilmente y las difíciles, más posibles".

Una especificación[editar]

Una principal, pero no técnica, diferencia entre Perl 5 y Perl 6 es que Perl 6 comienza como una especificación.[16] Esto significa que, si es necesario, Perl 6 puede ser reimplementado, y también significa que los programadores no necesitan leer el código fuente como último recurso para consultar el funcionamiento de alguna característica. La documentación de Perl 5 está considerada como excelente,[25] incluso fuera de la comunidad Perl, donde incluso la mezcla de las críticas dan una idea de su madurez y amplitud. Sin embargo, la documentación no se considera autorizada, y sólo describe el comportamiento real del intérprete de Perl 5 de forma informal. Las discrepancias encontradas entre la documentación y la aplicación pueden dar lugar a que se cambie uno para reflejar al otro, una dinámica que impulsa el continuo desarrollo y perfeccionamiento de las versiones de Perl 5.

Un sistema tipificado[editar]

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

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

Sin embargo, el tipificado estático es algo opcional, por lo que los programadores pueden hacer la mayor parte de las tareas sin usar ninguna clase de tipificado:

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

Perl 6 ofrece un sistema híbrido de tipificado donde el programador puede elegir usar tipificado estático, dinámico, o una mezcla de los dos.

Lista formal de parámetros de subrutinas[editar]

Perl 5 define las subrutinas sin listas de parámetros formales (aunque un simple conteo de parámetros y un flojo chequeo de tipos se pueden hacer con los "prototipos" de Perl 5). Los argumentos pasados a las subrutinas se convierten en alias dentro del array @_. Si los elementos de @_ se modifican, los cambios se reflejan en los datos originales.

Perl 6 presenta verdaderos parámetros formales al lenguaje.[27] 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 se marcan como constantes por lo que no se pueden modificar. Pueden ser declaradas explícitamente como alias de lectura-escritura del valor original o como copias usando las directivas is rw o is copy que el programador requiere para indicar que los valores serán modificados localmente.

Modos de pasar parámetros[editar]

Perl 6 proporciona tres modos básicos de la transmisión de parámetros:

  • Posicional
  • Nombre
  • Absorbido

Los parámetros posicionales son la típica lista ordenada de parámetros que la mayoría de los lenguajes de programación usan. Todos los parámetros también pueden transmitirse mediante el uso de su nombre en una manera desordenada. Un parámetro denominado con sólo su nombre sólo se puede pasar especificando su nombre (es decir, nunca se captura un argumento posicional), y se indican con un precedente carácter :. Parámetros absorbidos (indicados con un * antes del nombre del parámetro) son la herramienta de Perl 6 para la creación de funciones variadic. Un hash absorbido capturará los restantes pasados por nombre, mientras que un array absorbido capturará el resto de parámetros que se pasen por posición.

He aquí un ejemplo del uso de los tres modos de paso de parámetros:

 sub algunaFuncion($a, $b, :$c, :$d, *@e) (
   . . .
 )
 
 algunaFuncion(1, 2, :d(3), 4, 5, 6); # $a = 1, $b = 2, $d = 3, @e = (4, 5, 6)
 algunaFuncion(:b<2>, :a<1>); # $a="1", $b="2"

Los parámetros posicionales, como los indicados antes son siempre requeridos, a no ser que se sigan por ? para indicar que son opcionales. Los parámetros con nombre son opcionales por defecto, pero se pueden marcar como requeridos con la adición de ! después del nombre de la variable. Los parámetros absorbidos son siempre opcionales.

Bloques y clausuras[editar]

Los parámetros también se pueden pasar a bloques arbitrarios, que actúan como clausuras. Así es como, por ejemplo, se indican los iteradores de los bucles for y while. En el ejemplo siguiente, una lista se recorre, tres elementos a la vez, y se pasa al bloque del bucle como las variables, $a, $b y $c.[28]

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

Esto se conoce generalmente como un "sub puntado" o "bloque puntado", y la flecha se comporta casi exactamente igual que la palabra clave sub, al presentar una clausura anónima (o subrutina anónima en terminología de Perl 5).[27]

Invarianza del sigilo[editar]

En Perl 5, los sigilos –los caracteres especiales que preceden a los nombres de variables– cambian dependiendo de cómo se use la variable:

# Perl 5
my @array = ('a', 'b', 'c');
my $elemento = $array[1];    # $elemento es 'b'
my $elemento = @array[1];    # en 5.10, $elemento es 'b', con un aviso adicional
my @extracto = @array[1, 2]; # @extracto es ('b', 'c')

En Perl 6, los sigilos son invariantes, lo que significa que no cambian, tanto si se trata de un array entero o de un solo elemento del array:[26]

# Perl 6
my @array = 'a', 'b', 'c';
my $elemento = @array[1];    # $elemento es 'b'
my @extracto = @array[1];    # @extracto es ('b')
my @extracto = @array[1, 2]; # @extracto es ('b', 'c')

La varianza en Perl 5 se inspiró por el número del plural, algo muy común en muchos idiomas:

"Esta manzana"            # CORRECTA
"Estas manzanas"          # CORRECTA
"Esta tercera manzana"    # CORRECTA
"Estas tercera manzana"   # INCORRECTA

Sin embargo, este mapa conceptual se rompe cuando las referencias entran en juego, ya que pueden referirse a contenedores a pesar de que sean escalares. Así, manejar estructuras de datos anidadas puede requerir una expresión tanto en forma singular como plural, en un solo término:

 # Perl 5: recuperar una lista desde el nodo de un ''hash'' que contiene unos ''hash'' que contienen ''array''
 my @verbos_transitivos = @{ $diccionario{ 'verbo' }{ 'transitivo' } };

Esta complejidad no tiene equivalencia ni en el uso común del lenguaje natural ni en cualquier otro lenguaje de programación, y causa una alta carga cognitiva al escribir código para manipular complejas estructuras de datos. Comparar con Perl 6:

 # Perl 6: recuperar una lista desde el nodo de un ''hash'' que contiene unos ''hash'' que contienen ''array''
 my @verbos_transitivos = %dictionario{ 'verbo' }{ 'transitivo' }.list;

Programación orientada a objetos[editar]

Perl 5 soporta Programación orientada a objetos mediante un mecanismo conocido como bendición. Cualquier referencia se puede bendecir para ser un objeto de una determinada clase. Un objeto bendecido puede tener métodos invocados en ella utilizando la sintaxis "flecha" que hará que Perl localice o "despache" una subrutina apropiada según el nombre, y la llame con la variable bendecida como su primer argumento.

Si bien este modelo es extremadamente poderoso -prácticamente cualquier otro lenguaje de programación puede simular este modelo de objetos usando esta simple técnica- hace que el caso más común de la orientación a objetos -un objeto como si fuera una estructura de datos con algo de código asociado- innecesariamente complicado. Además, debido a que Perl no puede hacer suposiciones sobre el modelo de objetos en uso, la invocación de métodos no se puede optimizar muy bien.

En el espíritu de hacer "las cosas fáciles, fáciles, y las cosas difíciles, posibles", Perl 6 mantiene el modelo de la bendición, y proporciona un modelo de objetos más sólido para los casos comunes.[29] Por ejemplo, una clase para encapsular un punto de coordenadas cartesianas se puede definir y utilizar de esta manera:

 class Punto is rw {
   has $.x;
   has $.y;
 }
 
 my $punto = Punto.new( x => 1.2, y => -3.7 );
 
 # Ahora cambiamos x (note el método "x" usado como valor a la izquierda):
 $punto.x = 2;
 say "Punto está en la posición X: ", $punto.x;

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

En la terminología de Perl 6, $.x se llama "atributo". Algunos lenguajes llaman a esto campos o miembros. El método utilizado para acceder a un atributo se llama un descriptor de acceso. Los auto-accesores son métodos que se crean automáticamente, como el método x del ejemplo anterior. Estas funciones de acceso devuelven el valor del atributo. Cuando una clase o un atributo individual se declara con el modificador is rw (abreviatura de "lectura/escritura"), al auto-accesor se le puede pasar un nuevo valor para establecer el atributo, o puede asignarse directamente como un valor a la izquierda (como en el ejemplo). Auto-accesores se pueden sustituir por los métodos definidos por el usuario, si el deseo del programador es tener una interfaz más completa de un atributo. Los atributos sólo se pueden acceder directamente desde dentro de una definición de clase. Todos los demás accesos deben hacerse a través de los métodos de acceso.

El sistema de objetos de Perl 6 ha sido inspirado por el entorno de trabajo Moose que introduce muchas de las características de la programación orientada a objetos de Perl 6 a Perl 5.

Roles[editar]

Roles en Perl 6 toman la función de las interfaces en Java, mixins en Ruby, y rasgos[30] en la variante Squeak de Smalltalk. Son como las clases, pero son completamente abstractas. Se utilizan para realizar composición con otras clases en lugar de añadirse como en la cadena de herencia. Los roles definen tipos nominales; proporcionan nombres de semántica para las colecciones de comportamiento y estado. La diferencia fundamental entre un rol y una clase es que las clases son instanciables; los roles, no.[31]

En esencia, un rol es un conjunto (posiblemente abstracto) de métodos y atributos que se pueden agregar a una clase sin necesidad de utilizar herencia. Un rol también se puede añadir a un objeto individual; en este caso, Perl 6 creará una subclase anónima, agregará el rol a la subclase, y cambiará la clase del objeto a la subclase anónima.

Por ejemplo, un Perro es un Mamífero. Perro hereda ciertas características de los mamíferos, como las glándulas mamarias y (a través de los antecedentes de los mamíferos, los Vertebrados) una espalda. Los Perros pueden tener uno de varios tipos distintos de comportamiento; por ejemplo, un Perro puede ser una Mascota, a asilvestrarse, o ser Perro_guía para los ciegos. Sin embargo, estos son simplemente conjuntos de comportamientos adicionales que se pueden agregar a un Perro; un Gato también puede ser doméstico o silvestre, por ejemplo. Por lo tanto, Perro y Mamífero son clases, mientras Mascota, Silvestre, y Perro_guía son roles.

 class Mamífero is Vertebrado {
     . . .
 }
 class Perro is Mamífero {
     . . .
 }
 role Mascota {
     . . .
 }
 role Silvestre {
     . . .
 }
 role Perro_guía {
     . . .
 }

Los roles se agregan a una clase o un objeto con la palabra clave does, a diferencia de la de herencia is. Las palabras clave reflejan los diferentes significados de las dos características: composición con un rol da a una clase el comportamiento del rol, pero no indica que sea la misma cosa que el rol.

 class PerroGuía is Perro does Perro_guía {
     . . .
 }   # Subclase dotada con un rol
 
 my $perro = new Perro;
 $perro does Perro_guía;                         # Objeto individual dotado con un rol

Aunque los roles son distintos de las clases, los dos son tipos, por lo que un rol puede aparecer en una declaración de variable, donde normalmente se pondría una clase. Por ejemplo, un rol Ciego para un Humano puede incluir un atributo del tipo Perro_guía; este atributo podría contener un Perro_guía, un Caballo guía, a Guía Humano, o incluso una Guía Mecánica.

 class Humano {
     has Perro $perro;                     # Puede contener cualquier clase de Perro, tanto si hace el
     ...                                   # rol de Guía o no
 }
 role Ciego {
     has Perro_guía $guía;                 # Puede contener cualquier objeto que tenga un rol de Perro_guía,
     ...                                   # tanto si es un Perro o cualquier otro
 }

Expresiones regulares[editar]

Las expresiones regulares y el procesado de texto de Perl han sido siempre unas de sus características definitorias.[32] Debido a que desde hace un tiempo las construcciones de emparejamiento de patrones en Perl han excedido las capacidades de las expresiones regulares de los lenguajes formales,[33] la documentación de Perl 6 se referirá a ellas exclusivamente como regexen (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 entorno de trabajo llamado "reglas" (rules, (en inglés)) que ofrecen las posibilidades de los formalismos del análisis sensible al contexto (como el predicado sintáctico del analizado de expresiones gramaticales y Antlr), así como actuar como una clausura con respecto a su ámbito léxico[34] Las reglas se presentan con la palabra clave rule que tiene un uso muy similar a la definición de subrutinas. Reglas anónimas se pueden definir 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 (sustitución).

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'".[35]

Simplificación sintáctica[editar]

Algunas construcciones de Perl 5 se han cambiado en Perl 6, optimizadas para pistas sintácticas diferentes para los casos más comunes. Por ejemplo, los paréntesis requeridos en las estructuras de control en Perl 5 ahora son opcionales:[28]

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

También, el operador , (coma) es ahora un constructor de lista, así que los paréntesis ya no son necesarios alrededor de las listas. El código

 @array = 1, 2, 3, 4;

hace que @array sea un array con, exactamente, los elementos '1', '2', '3' y '4'.

Comparaciones encadenadas[editar]

Perl 6 permite "encadenar" las comparaciones. Es decir, una secuencia de comparaciones como las siguientes:

 if 20 <= $temperatura <= 25 {
     say "¡La temperatura de la habitación está entre 20 y 25!";
 }

Esto se trata como si se realizara cada comparación, de izquierda a derecha, y el resultado es combinado lógicamente con la operación and.

Evaluación perezosa[editar]

Perl 6 usa la técnica de la evaluación perezosa de listas que ha sido una característica de algunos lenguajes de la programación funcional, como el lenguaje Haskell:[36]

 @enteros = 0..Inf;  # enteros desde 0 al infinito

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 si sólo se seleccionan un número limitado de elementos.

Esto simplifica muchas tareas comunes en Perl 6 incluyendo las operaciones de entrada/salida, transformaciones de lista y paso de parámetros.

Reunión[editar]

Relativo a la evaluación perezosa es la construcción de listas perezosas usando gather y take, comportándose un poco como los generadores en lenguajes como Icon o Python.

 my $cuadrados = gather for 0..Inf {
     take $_ * $_;
 };

$cuadrados será una lista infinita de números cuadrados, pero la evaluación perezosa de gather asegura que los elementos solo se computan cuando sean accedidos.

Ensamblajes[editar]

Perl 6 introduce el concepto de ensamblajes (junctions, en inglés): valores que son compuestos de otros valores.[36] 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[37] ofrece una primera 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 los ensamblajes ahora ocupan un lugar central en el diseño de Perl 6.

En su forma más simple, los ensamblajes se crean 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)

| indica un valor que es igual tanto a su izquierda o los argumentos de su derecha. & indica un valor que es igual tanto a su izquierda y los argumentos de la derecha. Estos valores se pueden utilizar en cualquier código que utilice un valor normal. Las operaciones realizadas en un ensamblaje es para todos los miembros de la unión por igual, y combinan de acuerdo con el operador de yuxtaposición. Así, ("manzana"|"plátano") ~ "s" se convertirá en "manzanas"|"plátanos". En las comparaciones, los ensamblajes devuelven un único valor, verdadero o falso. El ensamblaje "any" devuelve verdadero si la comparación es cierta para alguno de los elementos del ensamblaje. El ensamblaje "all" devuelve verdadero si la comparación es cierta para todos los elementos del ensamblaje.

Los ensamblajes se pueden usar también para enriquecer el sistema de tipificado introduciendo un estilo de programación genérica, que se ajusta por los tipos de los ensamblajes:

 sub obtener_tinte(RGB_Color | CMYK_Color $color, Num $opacidad) {
     . . .
 }
 sub almacenar_registro(Registro & Almacén $reg) {
     . . .
 }

Autohilado[editar]

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

if $string ~~ all(@list_of_regexes) {
   ...
}

indicaría al compilador que todas las coincidencias de una cadena contra una lista de expresiones regulares se puede ejecutar concurrentemente, 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.[38] La paralelización del autohilado no está implementada todavía en ninguno de los compiladores de Perl 6.[39]

Macros[editar]

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.[40] Perl 6 se aprovechará de este concepto de macros del Lisp.[27] 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 analizadas, un árbol sintáctico representando código pre-analizado, o una combinación de los dos. Una definición de macro se parecería a esto::[41]

 macro hola($que) {
   quasi { say "Hola { {{{$que}}} }" };
 }

En este ejemplo particular, la macro no es más compleja que una sustitución al estilo del C, pero como el análisis 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.

Ejemplos[editar]

Hola mundo[editar]

El programa hola mundo es un programa común usado para introducir un lenguaje. En Perl 6 se puede escribir como

 say 'Hola mundo';

Aunque en Perl "hay más de una forma de hacerlo". La función say imprime sus argumentos, como la función print, pero añadiendo un carácter de nueva línea (esta característica se llevó a Perl v5.10).

Quicksort[editar]

Quicksort es un conocido algoritmo de ordenación. Una implementación funcional usando el paradigma de la programación funcional se puede escribir en Perl 6:

 # La lista vacía se ordena en la lista vacía
 multi quicksort([]) { () }
 
 # De otra forma, extrae el primer elemento como el pivote...
 multi quicksort([$pivote, *@resto]) {
 
     # Partición
     my @antes = @resto.grep(* <  $pivote);
     my @luego = @resto.grep(* >= $pivote);
 
     # Ordena las particiones
     (quicksort(@antes), $pivote, quicksort(@luego))
 }

Torres de Hanói[editar]

Las Torres de Hanói se usa a menudo en la ciencia de la computación para enseñar la programación recursiva. Esta implementación usa los mecanismos de despacho múltiple y restricciones paramétricas de Perl 6.

 multi sub hanoi(0, $, $, $) { }                         # No hay disco, no hacemos nada
 multi sub hanoi($n, $a = 'A', $b = 'B', $c = 'C') {     # Empezar con $n discos y tres clavijas: A, B, C
     hanoi $n - 1, $a, $c, $b;                           # Primero mover los primeros $n - 1 discos de A a B
     say "Mover disco $n de clavija $a a clavija $c";    # Entonces mover último disco de A a C
     hanoi $n - 1, $b, $a, $c;                           # Al final, mover $n - 1 discos de B a C
 }

Referencias[editar]

  1. a b Joab, Jackson (23 de julio de 2010). «Perl creator hints at imminent release of long-awaited Perl 6». IDG News Service. Consultado el 8 de febrero de 2015. 
  2. «Announce: Rakudo Star Release 2015.01». 7 de febrero de 2015. Consultado el 8 de febrero de 2015. 
  3. «Niecza Perl 6 v16». 
  4. «Glossary of Terms and Jargon». Perl Foundation Perl 6 Wiki. The Perl Foundation. 28 de febrero de 2011. Consultado el 8 de febrero de 2015. 
  5. «About Perl». perl.org. Consultado el 20 de abril de 2013. «"Perl" is a family of languages, "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 5".» 
  6. «Perl Foundation». «The Perl6 team will attempt to get a development release of version 1.0 available for Larry's birthday in September and a Version 1.0 release by Christmas. So it looks like Christmas 2015 was the Christmas that we were expecting.» 
  7. Michaud, Patrick (29 de julio de 2010). «Announce: Rakudo Star - a useful, usable, "early adopter" distribution of Perl 6». Consultado el 8 de febrero de 2015. 
  8. O'Rear, Stefan (29 de noviembre de 2011). «Niecza README.pod». Consultado el 12 de enero de 2012. 
  9. Kline, Joe (2000-08-21). «Report from the Perl Conference». 
  10. Wall, Larry (2000). «State of the Onion 2000». O'Reilly Network. 
  11. The Perl Foundation (2000). «About Perl6 RFCs». 
  12. Wall, Larry (2 de abril de 2001). «Apocalypse 1: The Ugly, the Bad, and the Good». 
  13. Larry Wall and the Perl 6 designers (2015). «Perl 6 Design Documents». 
  14. The Perl Foundation (2001). «Exegeses». 
  15. The Perl Foundation (2002). «Perl Development: Mailing Lists». 
  16. a b Larry Wall. [url=http://perlcabal.org/syn/S01.html «Synopsis 1: Overview»]. Consultado el 10 de agosto de 2004.  (en inglés)
  17. «rakudo/rakudo - GitHub». Github.com. Consultado el 21 de septiembre de 2013. 
  18. Michaud, Patrick (16 de enero de 2008). «The compiler formerly known as 'perl6'». 
  19. http://perl6.org/compilers/features
  20. Wall, Larry, et al. (2007). «Perl 6 STD». 
  21. «mp6/kp6 FAQ». Perl 6 development team. 2006. 
  22. «Yapsi README». 2011. 
  23. Wall, Larry (2004). «Synopsis 11 : Modules». 
  24. «Perl 6 Modules Directory». Modules.perl6.org. Consultado el 21 de septiembre de 2013. 
  25. Lhotsky, Brad (10 de marzo de 2004). «Thinking In Perl». 
  26. a b Larry Wall. «Synopsis 2: Bits and Pieces». Consultado el 20 de mayo de 2009.  (en inglés)
  27. a b c Larry Wall. «Synopsis 6: Subroutines». Consultado el 21 de marzo de 2003.  (en inglés)
  28. a b Wall, Larry (20 de mayo de 2009). «Synopsis 4: Blocks and Statements». 
  29. Larry Wall. «Synopsis 12: Objects».  (en inglés)
  30. The Software Composition Group (2003). «Traits». 
  31. chromatic (2009). «The Why of Perl Roles». 
  32. Parlante, Nick (2000). «Essential Perl: String Processing with Regular Expressions». 
  33. Christiansen, Tom (1996). «PERL5 Regular Expression Description». «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». 
  34. Wall, Larry (20 de mayo de 2009). «Synopsis 5: Regexes and Rules». 
  35. Larry Wall. «Apocalypse 5: Pattern Matching». Consultado el 4 de junio de 2002.  (en inglés)
  36. a b Larry Wall. «Synopsis 9: Data Structures». Consultado el 13 de septiembre de 2004.  (en inglés)
  37. Damian Conway (2002). «Quantum::Superpositions - QM-like superpositions in Perl».  (en inglés)
  38. «Autothreading specificication». 
  39. «Perl 6 feature matrix, section Concurrency».  (en inglés)
  40. Lamkins, David B. (8 de diciembre de 2004). «Capítulo 20». En bookfix.com. Successful Lisp: How to Understand and Use Common Lisp.  (en inglés)
  41. «Macros». 

Enlaces externos[editar]