Raku (lenguaje de programación)

El principal objetivo que Wall planteó en su discurso inicial fue la eliminación de defectos históricos. Estos incluían la confusión en torno al uso de símbolosselect para contenedores, la ambigüedad entre las funciones y el impacto sintáctico de los descriptores de archivo sin formato . Existían muchos otros problemas que los programadores de Perl habían estado discutiendo para solucionar durante años, y Wall los abordó explícitamente en su discurso.

Una consecuencia de estos objetivos fue que Perl 6 no tendría compatibilidad con versiones anteriores del código fuente existente. Esto significaba que parte del código que un compilador de Perl 5 interpretaba correctamente no sería aceptado por un compilador de Perl 6. Dado que la compatibilidad con versiones anteriores es un objetivo común al mejorar el software, los cambios incompatibles en Perl 6 debían indicarse explícitamente. La diferencia entre Perl 5 y Perl 6 se hizo tan grande que, finalmente, Perl 6 pasó a llamarse Raku.

La mascota del lenguaje es "Camelia, el insecto Raku". ^{[ 1 ]} Su nombre es un guiño a la mascota del camello asociada con Perl , y su forma, en la tradición de juegos de palabras de la comunidad Perl, es un juego de palabras con " error de software ". Los diseños en espiral incrustados en sus alas parecidas a mariposas se asemejan a los caracteres "P6", el apodo preferido para Perl 6, y la posición descentrada de los ojos es un juego de palabras intencional con "bizcocho". ^{[ 19 ]}

Uno de los objetivos detrás del diseño vivo y colorido del logotipo era desalentar la misoginia en la comunidad y que fuera una oportunidad para que aquellos de "persuasión masculina" mostraran su lado sensible. ^{[ 20 ]}

Pugs fue una implementación inicial de Perl 6 escrita en Haskell , liderada por Audrey Tang . Pugs solía ser la implementación más avanzada de Perl 6. A mediados de 2007, se encontraba prácticamente inactiva, con actualizaciones únicamente para seguir la última versión del Glasgow Haskell Compiler (GHC). En noviembre de 2014, Pugs ya no recibía mantenimiento. ^{[ 26 ]}

En 2007, v6-MiniPerl6 ("mp6") y su reimplementación, v6-KindaPerl6 ("kp6"), se escribieron como un medio para arrancar el STD de Perl-6.0.0, 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 código ejecutable es un sistema de arranque adecuado para Perl 6. kp6 actualmente es compilado por mp6 y puede trabajar con múltiples backends. ^{[ 27 ] [ 28 ]} mp6 y kp6 no son implementaciones completas de Perl 6 y están diseñados solo para implementar el conjunto mínimo de características requerido para arrancar un compilador completo de Perl 6.

Yapsi era un compilador y entorno de ejecución de Perl 6 escrito en Perl 6. Por lo tanto, requería un intérprete de Perl 6 existente, como una de las versiones de Rakudo Star, para ejecutarse. ^{[ 29 ]}

Niecza, otro importante esfuerzo de implementación de Perl 6, se centró en la optimización y la investigación de la implementación eficiente. Su objetivo es la Infraestructura de Lenguaje Común . ^{[ 30 ]}

Una diferencia no técnica importante entre Perl y Raku es que Raku comenzó como una especificación. ^{[ 33 ]} Esto significa que Raku puede reimplementarse si es necesario, y también que los programadores no tienen que leer el código fuente para obtener la información definitiva sobre cualquier característica. En cambio, en Perl, la documentación oficial no se considera autorizada y solo describe informalmente el comportamiento del intérprete de Perl. Cualquier discrepancia entre la documentación y la implementación puede llevar a que una se modifique para reflejar la otra, una dinámica que impulsa el desarrollo y perfeccionamiento continuos de las versiones de Perl.

En Raku, el sistema de tipos dinámicos de Perl se ha ampliado con la adición de tipos estáticos . ^{[ 34 ]} Por ejemplo:

mi Int $i = 0 ; mi Rat $r = 3.142 ; mi Str $s = "Hola, mundo" ; 

Sin embargo, el tipado estático sigue siendo opcional , por lo que los programadores pueden hacer la mayoría de las cosas sin ningún tipo de tipado explícito:

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

Raku ofrece un sistema de tipado gradual , mediante el cual el programador puede optar por utilizar tipado estático, tipado dinámico o una combinación de ambos.

Perl define subrutinas sin listas de parámetros formales (aunque se puede realizar un conteo simple de parámetros y alguna comprobación de tipos usando los "prototipos" de Perl). Los argumentos de la subrutina se asignan como alias a los elementos del array @_. Si se modifican los elementos de este array @_, los cambios se reflejan en los datos originales.

Raku introduce parámetros formales reales en el lenguaje. ^{[ 35 ]} En Raku, la declaración de una subrutina se ve así:

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

Al igual que en Perl, los parámetros formales (es decir, las variables en la lista de parámetros) son alias de los parámetros reales (los valores pasados), pero por defecto, los alias son constantes , por lo que no se pueden modificar. Se pueden declarar explícitamente como alias de lectura y escritura para el valor original o como copias usando las directivas is rwo is copyrespectivamente, si el programador necesita modificarlos localmente.

sub alguna función ( $a , $b , : $c , : $d , * @e ) { ... } algunafunción ( 1 , 2 , : d ( 3 ), 4 , 5 , 6 ); # $a=1, $b=2, $d=3, @e=(4,5,6)

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

En Perl, los símbolos ( los caracteres de puntuación que preceden al nombre de una variable ) cambian según cómo se utilice la variable:

# Código Perl mi @ array = ('a', 'b', 'c'); mi $elemento = $ array[1]; # $elemento es igual a 'b', mi @extract = @ array[1, 2]; # @extract es igual a ('b', 'c') mi $elemento = @ array[1]; # 'b' viene con una advertencia (opción 5.10)

En Raku, los sigilos son invariables, lo que significa que no cambian en función de si se necesita la matriz o el elemento de la matriz: ^{[ 34 ]}

# Código Raku mi @ array = 'a', 'b', 'c'; mi $elemento = @ array[1]; # $elemento es igual a 'b' mi @extract = @ array[1, 2]; # @extract es igual a ('b', 'c') mi @extract = @ array[1]; # @extract es igual a ('b')

La varianza en Perl está inspirada en la concordancia numérica del inglés y de muchos otros lenguajes naturales:

" Esta manzana." # $a CORRECTO " Estas manzanas." # @a CORRECTO " Esta tercera manzana." # $a[3] CORRECTO " Esta tercera manzana." # @a[3] INCORRECTO

Sin embargo, este mapeo conceptual falla al usar referencias , ya que estas pueden referirse a estructuras de datos aunque sean escalares. Por lo tanto, trabajar con estructuras de datos anidadas puede requerir la expresión tanto en singular como en plural en un solo término:

# Código Perl: recupera una lista de la hoja de un hash que contiene hashes que contienen matrices my @trans_verbs = @ { $dictionary { 'verb' }{ 'transitive' } };

Esta complejidad no tiene equivalente ni en el lenguaje natural de uso común ni en otros lenguajes de programación, y provoca una alta carga cognitiva al escribir código para manipular estructuras de datos complejas. Este es el mismo código en Raku:

# Código Raku: recupera una lista de la hoja de un hash que contiene hashes que contienen matrices my @trans_verbs = %dictionary<verb><transitive><> ; 

Perl admite la programación orientada a objetos mediante un mecanismo conocido como " bendición ". Cualquier referencia puede convertirse en un objeto de una clase específica. Se pueden invocar métodos sobre un objeto bendecido utilizando la sintaxis de flecha, lo que hará que Perl localice o "despache" la subrutina apropiada por su nombre y la llame con la variable bendecida como primer argumento.

Si bien es extremadamente potente, dificulta innecesariamente el caso más común de la programación orientada a objetos: un objeto tipo estructura con código asociado. Además, dado que Perl no puede hacer suposiciones sobre el modelo de objetos utilizado, la invocación de métodos no se puede optimizar adecuadamente.

Con el espíritu de hacer que "lo fácil sea fácil y lo difícil posible", Raku conserva el modelo de bendición y proporciona un modelo de objetos más robusto para los casos comunes. ^{[ 37 ]} Por ejemplo, una clase para encapsular un punto cartesiano podría definirse y usarse de esta manera:

clase Punto es rw { tiene $.x ; tiene $.y ; método distancia ( Punto $p ) { sqrt (( $!x - $p . x ) ** 2 + ( $!y - $p . y ) ** 2 ) } método distancia-al-centro { self . distancia: Punto . nuevo ( x => 0 , y => 0 ) } } mi $punto = Punto . nuevo ( x => 1.2 , y => - 3.7 ); decir "Ubicación del punto: (" , $punto . x , ', ' , $punto . y , ')' ; # SALIDA: Ubicación del punto: (1.2, -3.7)# Cambiando x e y (nótese que los métodos "x" e "y" se usan como lvalues): $point . x = 3 ; $point . y = 4 ; say "Ubicación del punto: (" , $point . x , ', ' , $point . y , ')' ; # SALIDA: Ubicación del punto: (3, 4)mi $other-point = Point . new ( x => - 5 , y => 10 ); $point . distance ( $other-point ); #=> 10 $point . distance-to-center ; #=> 5

El punto sustituye a la flecha como un guiño a los muchos otros lenguajes (por ejemplo, C++ , Java , Python , etc.) que se han alineado en torno al punto como sintaxis para la invocación de métodos.

En la terminología de Raku, $.xse denomina "atributo". Algunos lenguajes los llaman campos o miembros . El método utilizado para acceder a un atributo se denomina "accesor". Un método de acceso automático es un método creado automáticamente y nombrado según el nombre del atributo, como xen el ejemplo anterior. Estas funciones de acceso devuelven el valor del atributo. Cuando una clase o un atributo individual se declara con el is rwmodificador (abreviatura de "lectura/escritura"), se puede pasar un nuevo valor a los accesores automáticos para establecer el atributo, o se puede asignar directamente como un lvalue (como en el ejemplo). Los accesores automáticos pueden reemplazarse por métodos definidos por el usuario, si el programador desea una interfaz más rica para un atributo. Solo se puede acceder a los atributos directamente desde la definición de una clase mediante la $!sintaxis, independientemente de cómo se declaren los atributos. Cualquier otro acceso debe realizarse a través de los métodos de acceso.

El sistema de objetos Raku ha servido de inspiración para el framework Moose , que introduce muchas de las características de la programación orientada a objetos de Raku en Perl.

La clase Mamífero es Vertebrado { ... } La clase Perro es Mamífero { ... } rol Mascota { ... } rol Stray { ... } Guía de roles { ... } 

La clase Perro Guía es Perro hace Guía { ... } # La subclase compone el rolmi $perro = nuevo Perro ; $perro hace Guía ; # El objeto individual compone el rol

clase Humano { tiene Perro $perro ; # Puede contener cualquier tipo de perro, ya sea que haga el ... # rol de guía o no } rol Ciego { tiene Guía $guía ; # Puede contener cualquier objeto que haga el rol de Guía, ... # ya sea un Perro o cualquier otra cosa } 

El soporte de Perl para expresiones regulares y procesamiento de cadenas siempre ha sido una de sus características definitorias. ^{[ 42 ]} Dado que las construcciones de coincidencia de patrones de Perl han superado las capacidades de las expresiones regulares del lenguaje desde hace algún tiempo, ^{[ 43 ]} la documentación de Raku se refiere exclusivamente a ellas como regexes , alejando el término de la definición formal.

Raku proporciona un superconjunto de características de Perl con respecto a las expresiones regulares, integrándolas en un marco más amplio llamado " reglas " que proporciona las capacidades de formalismos de análisis sintáctico sensibles al contexto (como los predicados sintácticos de las gramáticas de expresiones de análisis sintáctico y ANTLR ), además de actuar como un cierre con respecto a su ámbito léxico . ^{[ 44 ]} Las reglas se introducen con la palabra clave que tiene un uso bastante similar a la definición de subrutina. Las reglas anónimas también se pueden introducir con la palabra clave (o ), o simplemente se pueden usar en línea como se hacía con las expresiones regulares en Perl a través de los operadores (coincidencia) o (sustitución).ruleregexrxms

En Apocalypse 5 , Larry Wall enumeró 20 problemas con la "cultura actual de las expresiones regulares". Entre ellos se encontraban que las expresiones regulares de Perl eran "demasiado compactas y 'bonitas'", tenían "demasiada dependencia de muy pocos metacaracteres", "poco soporte para capturas con nombre", "poco soporte para gramáticas" y "mala integración con el lenguaje 'real'". ^{[ 45 ]}

Algunas construcciones de Perl se han modificado en Raku, optimizándose para diferentes señales sintácticas en los casos más comunes. Por ejemplo, los paréntesis ( corchetes redondos ) necesarios en las construcciones de control de flujo en Perl ahora son opcionales: ^{[ 36 ]}

si es verdadero () { para @array { ... } } 

Además, el ,operador (coma) ahora es un constructor de listas, por lo que ya no se requieren paréntesis para encerrar las listas. El código

@array = 1 , 2 , 3 , 4 ; 

Ahora crea @arrayuna matriz con exactamente los elementos '1', '2', '3' y '4'.

Raku permite que las comparaciones se "encadenen". Es decir, se permite una secuencia de comparaciones como la siguiente:

Si 20 <= $temperatura <= 25 { decir "¡La temperatura ambiente está entre 20 y 25!" } 

Esto se trata como si cada comparación de izquierda a derecha se realizara por separado, y el resultado se combina lógicamente mediante la andoperación.

Raku utiliza el método de evaluación perezosa de listas que ha sido una característica de algunos lenguajes de programación funcional como Haskell : ^{[ 46 ]}

@integers = 0 .. Inf ; # números enteros desde 0 hasta infinito

El código anterior no fallará al intentar asignar una lista de tamaño infinito al array @integers, ni se quedará colgado indefinidamente al intentar expandir la lista si se busca en un número limitado de posiciones.

Esto simplifica muchas tareas comunes en Raku, incluidas las operaciones de entrada/salida , las transformaciones de listas y el paso de parámetros.

Relacionada con la evaluación perezosa está la construcción de listas perezosas usando gathery take, comportándose de forma similar a los generadores en lenguajes como Icon o Python .

mis $cuadrados = recolectar perezosamente para 0 .. Inf { tomar $_ * $_ ; }; 

$squaresserá una lista infinita de números cuadrados, pero la evaluación perezosa gathergarantiza que los elementos solo se calculen cuando se acceda a ellos.

Raku introduce el concepto de uniones : valores que son compuestos de otros valores. ^{[ 46 ]} En su forma más simple, las uniones se crean combinando un conjunto de valores con operadores de unión :

# Ejemplo para | ("cualquier") Unión: my $color = 'white' ; unless $color eq 'white' | 'black' | 'gray' | 'grey' { die "Impresión en color no compatible\n" ; } # Ejemplo para & ("all") Junction: my $password = 'secret!123' ; if $password ~~ /<:alpha>/ & / <:digit> / & / <:punct> / { say "Tu contraseña es razonablemente segura" ; } 

|indica un valor que es igual a sus argumentos izquierdo o derecho. &indica un valor que es igual a sus argumentos izquierdo y derecho. Estos valores se pueden usar en cualquier código que usaría un valor normal. Las operaciones realizadas en una unión actúan sobre todos los miembros de la unión por igual y se combinan según el operador juntivo. Por lo tanto, ("apple"|"banana") ~ "s"produciría "apples"|"bananas". En las comparaciones, las uniones devuelven un único resultado verdadero o falso para la comparación. " any" las uniones devuelven verdadero si la comparación es verdadera para cualquiera de los elementos de la unión. " all" las uniones devuelven verdadero si la comparación es verdadera para todos los elementos de la unión.

Las uniones también pueden utilizarse para ampliar de forma más rica el sistema de tipos mediante la introducción de un estilo de programación genérica que se limita a uniones de tipos:

subconjunto Color de Cualquier donde RGB_Color | CMYK_Color ; sub get_tint ( Color $color , Num $opacity ) { ... } 

En los lenguajes de bajo nivel, el concepto de macros se ha convertido en sinónimo de sustitución textual del código fuente debido al uso generalizado del preprocesador de C. Sin embargo, los lenguajes de alto nivel como Lisp precedieron a C en el uso de macros mucho más potentes. ^{[ 47 ]} Es este concepto de macro similar al de Lisp el que Raku aprovechará. ^{[ 35 ]} El poder de este tipo de macro radica en que opera sobre el programa como una estructura de datos de alto nivel , en lugar de como texto simple, y tiene a su disposición todas las capacidades del lenguaje de programación.

Una definición de macro de Raku se verá como una definición de subrutina o método, y puede operar sobre cadenas sin analizar, un AST que representa código preanalizado o una combinación de ambos. Una definición de macro se vería así: ^{[ 48 ]}

macro hola ( $what ) { quasi { decir "Hola { {{{$what}}} }" }; } 

En este ejemplo concreto, la macro no es más compleja que una sustitución textual al estilo C, pero dado que el análisis del parámetro de la macro se realiza antes de que esta opere sobre el código que la llama, los mensajes de diagnóstico serían mucho más informativos. Sin embargo, como el cuerpo de una macro se ejecuta en tiempo de compilación cada vez que se utiliza, se pueden emplear numerosas técnicas de optimización . Incluso es posible eliminar cálculos complejos de los programas resultantes realizando el trabajo en tiempo de compilación.

En Perl, los nombres de identificadores pueden usar caracteres alfanuméricos ASCII y guiones bajos, también disponibles en otros lenguajes. En Raku, los caracteres alfanuméricos pueden incluir la mayoría de los caracteres Unicode. Además, se pueden usar guiones y apóstrofes (con ciertas restricciones, como no ir seguidos de un dígito). El uso de guiones en lugar de guiones bajos para separar palabras en un nombre da lugar a un estilo de nomenclatura llamado " kebab case ".

El programa "Hola mundo" es un programa común que se utiliza para introducir un lenguaje. En Raku, "Hola mundo" es:

di 'Hola, mundo' ; 

— aunque hay más de una manera de hacerlo .

La función factorial en Raku, definida de varias maneras diferentes:

# Usando recursión (con la construcción `if\else`) sub fact ( UInt $n --> UInt ) { if $n == 0 { 1 } else { $n * fact ( $n-1 ) } } # Usando recursión (con `if` como modificador de instrucción) sub fact ( UInt $n --> UInt ) { return 1 if $n == 0 ; return $n * fact ( $n-1 ); } # Usando recursión (con la construcción `when`) sub fact ( UInt $n --> UInt ) { when $n == 0 { 1 } default { $n * fact ( $n-1 ) } } # Usando el operador ternario sub fact ( UInt $n --> UInt ) { $n == 0 ?? 1 !! $n * fact ( $n-1 ) } # Usando despacho múltiple multi fact ( 0 ) { 1 } multi fact ( UInt $n --> UInt ) { $n * fact ( $n - 1 ) } # Usando el metaoperador de reducción sub fact ( UInt $n --> UInt ) { [*] 1 .. $n } # Creación de un operador factorial y uso del subpostfijo del metaoperador de reducción : <!>( UInt $n --> UInt ) { [*] 1 .. $n } # Usando el declarador `state` para crear un factorial memorizado sub fact ( UInt $n --> UInt ) { state %known = 0 => 1 ; return %known { $n } if %known { $n }: exists ; %known { $n } = $n * fact ( $n-1 ); return %known { $n }; } 

Quicksort es un algoritmo de ordenación muy conocido. Una implementación funcional ^{[ a ]} que utiliza el paradigma de programación funcional se puede escribir sucintamente en Raku:

# La lista vacía se ordena como una lista vacía multi quicksort ([]) { () } # De lo contrario, extraiga el primer elemento como pivote... multi quicksort ([ $pivot , * @rest ]) { # Partición. my @before = @rest . grep (* < $pivot ); my @after = @rest . grep (* >= $pivot ); # Ordenar las particiones. flat ( quicksort ( @before ), $pivot , quicksort ( @after )) } 

La Torre de Hanoi se utiliza a menudo para introducir la programación recursiva en la informática. Esta implementación utiliza el mecanismo de despacho múltiple de Raku y restricciones paramétricas:

multi sub hanoi ( 0 , $, $, $) { } # No hay disco, así que no hagas nada multi sub hanoi ( $n , $a = 'A' , $b = 'B' , $c = 'C' ) { # Comienza con $n discos y tres clavijas A, B, C hanoi $n - 1 , $a , $c , $b ; # primero mueve los $n - 1 discos superiores de A a B say "Mover disco $n de la clavija $a a la clavija $c" ; # luego mueve el último disco de A a C hanoi $n - 1 , $b , $a , $c ; # por último mueve los $n - 1 discos de B a C } 

• Randal, Allison; Sugalski, Dan; Tötsch, Leopold (2003). Perl 6 Essentials (1.ª  ed.). O'Reilly Media. ISBN 978-0-596-00499-6.
• Randal, Allison; Sugalski, Dan; Tötsch, Leopold (2004). Perl 6 y Parrot Essentials (2.ª  ed.). O'Reilly Media. ISBN 978-0-596-00737-9.
• Walters, Scott (15 de diciembre de 2004). Perl 6 ahora: Las ideas principales ilustradas con Perl 5. Expert's Voice in Open Source. ISBN 978-1-59059-395-0.

Asimismo, en 2009 se publicó un libro dedicado a Parrot, una de las primeras máquinas virtuales de Perl 6.

• Randal, Allison; Whitworth, Andrew (15 de junio de 2009). Guía del desarrollador de Parrot: Pir . Onyx Neon Press. ISBN 978-0-9779201-2-9Archivado del original el 18 de octubre de 2016. Consultado el 24 de julio de 2017 .

• Shitov, Andrew (2017). Perl 6 de un vistazo . Amazon Digital Services LLC - KDP. ISBN 978-90-821568-3-6.
• Rosenfeld, Laurent; Downey, Allen B. (2017). Think Perl 6. O'Reilly Media. ISBN 978-1-4919-8055-2.
• Merelo, JJ (9 de julio de 2017). Aprender a programar con Perl 6: Primeros pasos: Iniciarse en la programación sin salir de la línea de comandos . Aprender a programar con Perl. ISBN 978-1-5217-9578-1.
• Lenz, Moritz (27 de julio de 2017). Fundamentos de Perl 6 . Presione. ISBN 978-1-4842-2898-2.
• Shitov, Andrew (7 de septiembre de 2017). Perl 6 Deep Dive . Packt Publishing, Limited. ISBN 978-1-78728-204-9.
• Shitov, Andrew (2017). Uso de Perl 6. ISBN 978-90-821568-1-2.
• Szabo, Gabor (3 de diciembre de 2017). Desarrollo de aplicaciones web en Perl 6. Autor.
• Lenz, Moritz (4 de diciembre de 2017). Análisis sintáctico con expresiones regulares y gramáticas de Perl 6: Un descenso recursivo al análisis sintáctico . Apress. ISBN 978-1-4842-3228-6.
• Foy, Brian D. (2018). Aprendiendo Perl 6. O'Reilly Media. ISBN 978-1-4919-7768-2.

• Shitov, Andrew (13 de octubre de 2019). Uso de Raku: 100 desafíos de programación resueltos en el lenguaje de programación Raku (2.ª  ed.). Suzi K Edwards. ISBN 978-90-821568-8-1.
• Shitov, Andrew (18 de octubre de 2019). Raku One-Liners: Cómo aprovechar al máximo la sintaxis expresiva de Raku para tus rutinas diarias . Amazon Digital Services LLC - KDP. ISBN 978-90-821568-9-8.
• Lenz, Moritz (6 de septiembre de 2020). Fundamentos del Raku: Una introducción con ejemplos, proyectos y estudios de caso . Apress. doi : 10.1007/978-1-4842-6109-5 . ISBN 978-1-4842-6108-8.