Introducción a Perl 6

Perl 6 es un lenguaje de alto nivel, de propósito general y de tipado gradual. Perl 6 es multiparadigma y soporta programación Procedimental, Orientada a Objetos y Funcional.

Instalación de Rakudo Star desde la línea de comandos:

Tienes más información en http://rakudo.org/how-to-get-rakudo/#Installing-Rakudo-Star-Linux

Tienes cuatro opciones:

Puedes ejecutar código Perl 6 mediante REPL (Read-Eval-Print Loop). Para ello, abre un terminal, introduce perl6 y pulsa [Enter]. Aparecerá el prompt >. Ahora introduce una línea de código, pulsa [Enter] y aparecerá una línea nueva con el resultado. Puedes introducir otra línea o exit y pulsar [Enter] para salir al sistema.

También puedes escribir tu código de Perl 6 en un archivo de texto, guardarlo y ejecutarlo. Es recomendable que el nombre de este archivo de texto tenga la extensión .p6. Ejecuta el archivo de esta forma: perl6 nombre-archivo.p6 desde un terminal y pulsa [Enter]. La ejecución suele mostrar el resultado de sentencias como say para visualizar por la salida estándar contenidos de texto con un salto de línea al final .

REPL normalmente se utiliza para probar trozos pequeños de código, como una línea. En el caso de programas con más de una línea de código es recomendable guardarlos en un archivo y ejecutarlos como hemos visto.

También puedes ejecutar una línea de código de forma "in-line" mediante el parámetro -e de la siguiente forma: perl6 -e 'línea de código Perl 6' y pulsando [Enter].

Como casi siempre vamos a guardar nuestros programas de Perl 6 en archivos, necesitamos un editor de textos decente que reconozca la sintaxis de Perl 6.

Yo recomiendo y utilizo Atom. Es un editor de textos moderno que reconoce y visualiza bien la sintaxis de Perl 6. Perl 6 FE es un paquete de Atom con una visualización alternativa de la sintaxis de Perl 6. Deriva del paquete original, tiene muchas correcciones y más funcionalidades.

En la comunidad también se utiliza Vim, Emacs o Padre.

Las últimas versiones de Vim incorporan la visualización de la sintaxis de Perl 6, mientras que Emacs y Padre necesitan instalar paquetes adicionales.

Comenzamos con El ritual hola mundo.

que también puede escribirse como:

Perl 6 tiene forma libre: generalmente los espacios en blanco carecen de significado salvo en ciertos casos.

Una Sentencia normalmente es una línea lógica de código que finaliza en punto y coma: say "Hola" if True;

Las Expresiones son sentencias especiales que devuelven un valor: 1+2 devuelve 3

Las expresiones están formadas por Términos y Operadores.

Los Términos pueden ser:

Los Operadores se clasifican en estos tipos:

La siguiente tabla muestra los operadores más utilizados.

Al agregar R delante de cualquier operador hace que se intercambien sus operandos.

La reducción de operadores se utiliza en listas de valores. Se forman encerrando el operador entre corchetes []

Un escalar contiene un valor o referencia.

Dependiendo del valor que aloje, se pueden realizar un conjunto específico de operaciones en un escalar.

Los Arrays son listas que contienen varios valores.

Se pueden realizar muchas operaciones con arrays, como las de este ejemplo:

.elems devuelve el número de elementos de un array.
.push() añade uno o más elementos a un array.
Podemos acceder a un elemento concreto del array indicando su posición @animales[0].
.pop elimina el último elemento del array y lo devuelve.
.splice(a,b) elimina b elementos que comienzan en la posición a.

Algunos de los métodos aplicables a los hashes son:

.push: (Clave => 'Valor') agrega un nuevo par clave/valor.
.kv devuelve una lista con todas las claves y valores.
.keys devuelve una lista con todas las claves.
.values devuelve una lista con todos los valores.
Podemos acceder a un valor concreto del hash indicando su clave %hash<clave>

En los ejemplos anteriores no hemos especificado el tipo de valor que debería contener cada variable.

Como puedes ver en el ejemplo anterior, el tipo de valor en $var primero fue texto (Str) y después entero (Int).

Este estilo de programación se caracteriza por ser de tipado dinámico. Dinámico en el sentido de que las variables pueden contener valores de Cualquier tipo.

Ahora intenta ejecutar el siguiente ejemplo:
Fíjate en el Int indicado antes de la variable.

Este ejemplo devuelve un error indicando: Type check failed in assignment to $var; expected Int but got Str

Lo que ocurre es que hemos especificado como entero (Int) el tipo de la variable y falla al intentar asignar en ella un texto (Str).

Este estilo de programación se caracteriza por ser de tipado estático. Estático en el sentido de que la variable se define con un tipo determinado antes de asignarla y este tipo no puede cambiarse después.

Perl 6 es un lenguaje de tipado gradual; lo que permite tipado estático y dinámico.

Es posible que nunca utilices los dos primeros, pero aparecen en la siguiente lista para que sepas que existen.

Introspección es el proceso para adquirir información sobre las propiedades de un objeto, como por ejemplo su tipo.
En uno de los ejemplos anteriores utilizamos .WHAT para conocer el tipo de una variable.

El tipo de una variable que contiene un valor se corresponde con su valor.
El tipo de una variable declarada de forma estática y sin valor es el tipo con el que se ha declarado.
El tipo de una variable vacía que no ha sido declarada de forma estática es (Any).
Asigna Nil a una variable para eliminar su valor.

Es necesario declarar una variable antes de utilizarla.

Perl 6 dispone de varias formas de declaración, y de momento estamos utilizando my.

La forma de declaración my proporciona a la variable un alcance léxico. Dicho de otro modo, la variable solo es accesible desde el mismo bloque donde es declarada.

En Perl 6 un bloque está delimitado por { }.

En caso de no existir bloque, la variable estará disponible en el script entero.

Como la variable solo es accesible dentro del bloque donde está definida, el mismo nombre de variable puede utilizarse en cualquier otro bloque.

En los ejemplos anteriores hemos visto cómo asignar valores a variables.
La asignación se realiza mediante el operador =.

Y podemos cambiar el valor asignado a la variable:

Por otro lado, no podemos cambiar el valor vinculado de una variable.

La vinculación se realiza mediante el operador :=.

Como has visto, la vinculación de variables es bidireccional.
$a := $b y $b := $a tienen el mismo efecto.

El código se ejecuta solo si se cumple una condición, por ej., una expresión se evalúa como True.

En Perl 6 podemos invertir el código y la condición, y aún así la condición siempre se evalúa primero.

Si la condición no se cumple, podemos especificar bloques alternativos de ejecución utilizando:

La negación de if es unless.

El siguiente código:

puede escribirse como:

La negación en Perl 6 se realiza con ! o con not.

unless (condición) se utiliza en lugar de if not (condición).

unless no puede utilizar la claúsula else.

with es como if pero solo comprueba si la variable está definida.

No ocurre nada si ejecutas el código sin asignar un valor a la variable.

without es la negación de with y es parecido a unless.

Si la primera condición with no se cumple, puedes indicar una alternativa mediante orwith.
with y orwith son parecidos a if y elsif.

for itera sobre una serie de valores.

Observa que en la iteración hemos creado la variable $array-item para realizar después la operación *100 en cada elemento del array.

En Perl 6 given viene a ser switch en otros lenguajes, pero mucho más potente.

Cuando se produce la coincidencia no se evalúan las demás.

Como opción, proceed continúa la evaluación aunque se produzca la coincidencia.

loop es otra forma de escribir un for.

Actualmente loop viene a ser el for utilizado en la familia de lenguajes de C.

Perl 6 pertenece a la familia de lenguajes de C.

Podemos utilizar dos subrutinas para ejecutar comandos de la shell:

echo y ls son palabras clave típicas de la shell de Linux:
echo visualiza texto en el terminal (es el equivalente a print en Perl 6)
ls muestra un listado de todos los archivos y carpetas del directorio actual

dir en Windows es el equivalente de ls en Linux.

Perl 6 puede mostrar el contenido de una carpeta sin recurrir a los comandos de la shell (utilizando ls por ejemplo).

Además, puedes crear y eliminar carpetas.

mkdir crea una carpeta nueva.
rmdir elimina una carpeta vacía y devuelve un error sino está vacía.

También puedes comprobar si una ruta existe y si es un archivo o una carpeta:

Crea una carpeta vacía llamada carpeta123, un archivo vacío llamado script123.p6 y el siguiente script:

Ejecuta el script.

IO.e comprueba si existe la carpeta/archivo.
IO.f comprueba si la ruta es un archivo.
IO.d comprueba si la ruta es una carpeta.

Las Subrutinas (también denominadas subs o funciones) son una forma de empaquetar y reutilizar funcionalidades.

La definición de una subrutina comienza con la palabra clave sub. Una vez definida puede invocarse mediante su nombre.

Fíjate en el siguiente ejemplo:

El ejemplo anterior es una subrutina sin entrada de datos.

Las subrutinas pueden requerir una entrada, y ésta se proporciona mediante argumentos. Una subrutina puede definir ninguno o varios parámetros. La signatura de una subrutina es el número y el tipo de los parámetros que puede definir.

La siguiente subrutina acepta un argumento de tipo string.

Es posible definir varias subrutinas con el mismo nombre pero con signaturas diferentes. Cuando se llama a la subrutina, se decidirá qué versión utilizar en tiempo de ejecución dependiendo del número y tipo de argumentos proporcionados. Este tipo de subrutinas se definen de la misma forma que una subrutina normal pero utilizando la palabra clave multi en lugar de sub.

Tendremos un error si se define una subrutina para aceptar un argumento y éste no es proporcionado.

Con Perl 6 podemos definir subrutinas con:

Un parámetro opcional se define añadiendo ? al nombre del parámetro.

Si no es necesario proporcionar un argumento, puede definirse uno por defecto asignándole un valor al parámetro en la definición de la subrutina.

Hemos visto que todas las subrutinas hasta ahora siempre hacen algo: mostrar resultados en la pantalla del terminal.

Sin embargo y a veces, utilizamos una subrutina para que nos devuelva algún valor que podamos utilizar después en el flujo del programa.

Si una función se ejecuta hasta el final de su bloque, el valor de retorno vendrá determinado por la última declaración o expresión.

Para dejarlo más claro sería una buena idea especificar de forma explícita qué es lo que queremos devolver. Esto se realiza mediante la palabra clave return.

Las funciones/subrutinas son de primera clase:

Un gran ejemplo es la función map.
map es una función de orden superior que puede aceptar otra función como argumento.

Hemos definido la subrutina cuadrado que toma un argumento y lo multiplica por sí mismo.
Después utilizamos map, una función de orden superior, que toma dos argumentos: la subrutina cuadrado y un array.
El resultado es una lista de los cuadrados de cada elemento del array.

Ten en cuenta que cuando pasamos una subrutina como argumento, es necesario utilizar el prefijo & en el nombre.

Una función anónima también se denomina lambda.
Una función anónima no está vinculada a un identificador (no tiene nombre).

Escribamos de nuevo el ejemplo de map pero utilizando una función anónima

Observa que en lugar de declarar la subrutina cuadrado y pasarla a map como argumento, la definimos dentro de la función anónima como -> $x {$x ** 2}.

En la jerga de Perl 6 nos referimos a esta notación como punto de entrada al bloque

En Perl 6 los métodos pueden encadenarse, de forma que el resultado de un método pasa como argumento a otro método.

Un ejemplo: dado un array, necesitamos los valores únicos de ese array ordenados de mayor a menor.

A continuación una solución sin encadenamiento:

Aquí llamamos unique sobre @array, pasamos el resultado como argumento a sort y pasamos el resultado a reverse.

En contraste, con métodos encadenados, el ejemplo anterior puede escribirse así:

Como ves, el encadenamiento de métodos es más visual.

El operador de alimentación, llamado tubería en algunos lenguajes de programación funcional, ejemplifica el encadenamiento de métodos.

Fíjate en el flujo de las llamadas a los métodos: se produce de arriba hacia abajo, esto es, desde el primero hasta el último paso.

La alimentación hacia atrás es parecida a la anterior pero al revés.
El flujo de las llamadas a los métodos es de abajo hacia arriba, esto es, desde el paso final hacia el primero.

El hiperoperador >>. puede aplicar un método a todos los elementos de una lista y devolver una lista con los resultados.

Mediante el hiperoperador podemos utilizar todos los métodos ya definidos en Perl 6, por ej. is-prime que devuelve si un número es primo o no.
Además, podemos definir funciones nuevas y utilizarlas mediante el hiperoperador agregando el prefijo & en el nombre del método, por ej. &es-par.

El uso del hiperoperador es muy práctico pues evita escribir un bucle for para iterar sobre cada valor.

Un ensamblaje es una superposición lógica de valores.

En el siguiente ejemplo 1|2|3 es un ensamblaje.

El uso de ensamblajes normalmente produce autothreading para cada elemento del ensamblaje y todos los resultados se combinan y se devuelven en un nuevo ensamblaje.

Una lista perezosa es una lista que se evalúa perezosamente.
La evaluación perezosa demora la evaluación de una expresión hasta que es requerida, guardando mientras los resultados en una tabla de búsqueda para así evitar repetir la evaluación.

Entre los beneficios tenemos:

Podemos definir una lista perezosa utilizando el operador infijo …​
Una lista perezosa tiene elemento(s) inicial(es), un generador y un punto final.

El elemento inicial es 1 y el punto final es 10. Como no hemos definido un generador, por defecto es el sucesor (+1)
Dicho de otra forma, esta lista perezosa puede devolver (si es requerida) los siguientes elementos (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Esta lista puede devolver (si es requerida) cualquier entero entre 1 e infinito, en otras palabras cualquier número entero.

Los elementos iniciales son 0 y 2, y el punto final es 10. Aunque no hay un generador definido, Perl 6 utiliza los elementos iniciales para deducir que el generador es (+2)
Esta lista puede devolver (si es requerida) los siguientes elementos (0, 2, 4, 6, 8, 10)

En este ejemplo hemos definido de forma explícita un generador entre llaves { }
Esta lista puede devolver (si es requerida) los siguientes elementos (0, 3, 6, 9, 12)

Todos los objetos de código en Perl 6 son clausuras, lo que significa que se pueden referenciar variables léxicamente definidas desde un ámbito externo.

Si ejecutas el código anterior verás en el terminal Buenos días Juan Dios.
El resultado es simple, pero lo interesante es que se devuelve la subrutina interna saludo desde una subrutina externa antes de ser ejecutada.

$saludo-creado es una clausura.

Una clausura es una especie de objeto especial que combina dos cosas:

El entorno es cualquier variable local que estaba dentro del alcance en el momento que se creó la clausura. En este caso, $saludo-creado es una clausura que incluye a la subrutina saludo y el texto Juan Dios que existía cuando se creó la clausura.

Veamos un ejemplo más interesante.

En este ejemplo hemos definido la subrutina crear-saludo($momento) aceptando el argumento $momento y devuelve una subrutina nueva. La subrutina devuelta acepta el argumento $nombre y devuelve el saludo.

crear-saludo es una fábrica de subrutinas, y en este ejemplo hemos creado dos subrutinas nuevas, una para decir Buenas Tardes y otra para decir Buenas Noches.

$tardes y $noches también son clausuras. Ambas comparten la misma definición del cuerpo de la subrutina pero alojan entornos distintos.
En el entorno de $tardes el $momento es Tardes y en el entorno de $noches el $momento es Noches.

La programación Orientada a Objetos es uno de los paradigmas de programación más utilizados actualmente.
Un objeto es un conjunto de variables y subrutinas.
Las variables se llaman atributos y las subrutinas se llaman métodos.
Los atributos definen un estado y los métodos definen el comportamiento de un objeto.

Una clase es una plantilla para crear objetos.

Para entender esta relación veamos el siguiente ejemplo:

En orientación a objetos decimos que los objetos son instancias de una clase.

Veamos el siguiente script:

La palabra clave class se utiliza para definir una clase.
La palabra clave has se utiliza para definir los atributos de una clase.
El método .new() se denomina constructor y crea el objeto como una instancia de la clase a la que ha sido llamada.

En el script anterior, la variable nueva $juan tiene una referencia a una instancia nueva de "Humano" definida por Humano.new().

Los argumentos que se pasan al método .new() son utilizados para establecer los atributos del objeto en cuestión.

Una clase puede tener un alcance léxico mediante my:

La encapsulación es un concepto de la programación Orientada a Objetos que consiste en empaquetar un conjunto de datos y métodos.

Los datos (atributos) dentro de un objeto deben ser privados, dicho de otro modo, solo son accesibles desde dentro del objeto.
Para acceder a los atributos de un objeto desde fuera de él utilizamos métodos de acceso.

Los siguientes dos scripts dan el mismo resultado.

El método sayvar es un método de acceso que nos permite acceder al valor de la variable sin acceder directamente a ella.

Perl 6 realiza la encapsulación mediante twigils (sigilos secundarios) y se ubican entre el sigilo y el nombre del atributo.
En las clases se utilizan dos twigils:

Por defecto todos los atributos son privados pero es muy recomendable utilizar siempre el twigil !.

Por lo tanto, podemos reescribir la clase anterior como:

Si añades al script la siguiente sentencia: say $juan.edad; devolverá el siguiente error: Method 'edad' not found for invocant of class 'Humano' debido a que $!edad es un atributo privado y solo puede utilizarse desde dentro del objeto. Como hemos visto, tendremos un error al intentar acceder a este atributo desde fuera del objeto.

Sustituye has $!edad por has $.edad y comprueba el resultado de say $juan.edad;

En Perl 6 todas las clases heredan un constructor .new() por defecto que puede utilizarse para crear objetos proporcionando argumentos.
El constructor por defecto solo acepta argumentos con nombre.
Como puedes ver en el ejemplo que vimos antes, los argumentos que tiene .new() están definidos con un nombre:

¿Puedo ahorrarme el nombre de cada atributo al crear un objeto? Sí, pero necesito crear otro constructor que acepte argumentos posicionales.

Los atributos de Clase son atributos que pertenecen a la clase en sí y no a sus objetos.
Pueden inicializarse durante su definición.
Los atributos de Clase se declaran mediante my en lugar de has.
Se llaman en la clase en sí en lugar de sus objetos.

Todos los ejemplos que hemos visto hasta ahora utilizan métodos de acceso para conseguir la información de los atributos de los objetos.

¿Y si necesitamos modificar el valor de un atributo?
Para ello necesitamos etiquetar ese atributo como lectura/escritura utilizando las palabras clave is rw

Todos los atributos se declaran por defecto como solo lectura y también puedes hacerlo de forma explícita mediante is readonly

Perl 6 permite la herencia múltiple. Una clase puede heredar de varias clases.

La clase multi-gráfica debería ser capaz de tener dos series, una para los valores actuales de las barras y otra para los valores de las previsiones de las líneas.
Por esa razón la hemos definido como hija de graf-líneas y graf-barras.
Te habrás dado cuenta que al llamar al método dibujar en multi-gráfica no tenemos el resultado deseado. Solo se dibuja una serie.
¿Qué ha ocurrido?
multi-gráfica hereda de graf-líneas y de graf-barras y ambas tienen un método llamado dibujar. Cuando llamamos a ese método desde multi-gráfica Perl 6 trata de resolver internamente el conflicto llamando a uno de los métodos heredados.

Para que funcione correctamente necesitamos anular la herencia del método dibujar en multi-gráfica.

Los Roles son similares a las clases en cuanto a que son una colección de atributos y métodos.

Los roles se declaran con la palabra clave role. Las clases que quieran implementar un rol, pueden hacerlo utilizando la palabra clave does.

Verás que el resultado es el mismo que antes sin utilizar roles.

Y ahora te preguntarás: si un rol es como una clase ¿para qué se utilizan?
Para responder la pregunta, modifica el primer script que hemos utilizado para mostrar el caso de la herencia múltiple, en el que olvidamos anular la herencia del método dibujar.

Tendremos un error en tiempo de compilación si aplicamos varios roles a la misma clase si existe un conflicto.
Este enfoque es mucho más seguro que la herencia múltiple, donde los conflictos no se consideran errores y se resuelven simplemente en tiempo de ejecución.

Los roles te avisarán si existe un conflicto.

La Introspección es la forma de conseguir información de un objeto; como su tipo, atributos o métodos.

La introspeción proporciona la siguiente información:

Las excepciones son situaciones especiales que ocurren en tiempo de ejecución cuando algo va mal.
Decimos que las excepciones son lanzadas.

Veamos una ejecución correcta como en el siguiente script:

Ahora veamos un script que lanza una excepción:

Debes tener en cuenta que cuando se produce un error (en este caso, debido a la asignación de un número a una variable de texto) el programa se interrumpirá y no evaluará cualquier otra línea de código.

El Control de excepciones se produce cuando se lanza una excepción y es capturada de forma que el script continúa su ejecución.

El Control de excepciones se realiza utilizando un bloque try-catch.

El bloque CATCH puede definirse igual que el bloque given. Esto significa que podemos capturar y controlar distintos tipos de excepciones.

Perl 6 también te permite lanzar excepciones de forma explícita.
Se pueden lanzar dos tipos de excepciones:

Las excepciones ad-hoc se lanzan utilizando la subrutina die, seguida del mensaje describiendo la excepción.

Las excepciones por tipo son objetos, y como vemos en el ejemplo anterior utilizan el constructor .new().
Todas las excepciones por tipo pertenecen a la clase X. Estos son algunos ejemplos:
X::AdHoc es el tipo de excepción más simple
X::IO errores relacionados con operaciones de E/S
X::OS errores relacionados con el Sistema Operativo
X::Str::Numeric errores relacionados con la conversión de una cadena de texto a un valor numérico

Una expresión regular puede definirse así:

A menos que se indique de forma explícita, el espacio en blanco es ignorado, da igual m/ilumina/ que m/ ilumina /.

Los caracteres alfanuméricos y el guión bajo _ se escriben tal cual.
El resto de caracteres deben ser escapados utilizando la barra invertida o backslash o ir entre comillas.

Los caracteres se pueden clasificar en categorías y podemos realizar comparaciones con ellas.
También podemos comparar la inversa de la categoría (todo menos ella):

Lo normal es comparar categorías de caracteres como hemos visto.
Dicho esto, podemos tener un enfoque más sistemático utilizando propiedades Unicode, de forma que puedas realizar coincidencias con categorías de caracteres dentro y fuera del estandar ASCII.
Las propiedades Unicode se indican entre <: >

En una regex también se pueden utilizar comodines.

El punto . significa cualquier caracter.

Los cuantificadores van después de un caracter y especifican cuantas veces se repite éste.

El interrogante ? significa que se repite una vez o ninguna.

El asterisco * significa que se repite una vez o más de una vez o ninguna.

El símbolo + significa que se repite al menos una vez.

Cuando se encuentra el patrón buscado, el resultado se guarda en la variable especial $/

$/ devuelve un Objeto de Coincidencia (el texto encontrado o resultado de la regex)
El Objeto de Coincidencia tiene los siguientes métodos:
.prematch devuelve el texto que hay antes del resultado.
.postmatch devuelve el texto que hay después del resultado.
.from devuelve la posición inicial del resultado.
.to devuelve la posición final del resultado.

Vamos a comprobar si una dirección de email es correcta o no.
Para este ejemplo asumiremos que una dirección de email correcta tiene este formato:
nombre [punto] apellido [arroba] compañía [punto] (com/org/net)

juan.dios@perl6.org es un email válido

<:L> coincide con una letra
<:L>+ coincide con una letra o más
\. coincide con un caracter de [punto]
\@ coincide con un caracter de [arroba]
<:L+:N> coincide con una letra o más de una y un número
<:L+:N>+ coincide con una o más (una o más letras y un número)

La regex se puede descomponer así:

Una regex con nombre se define de la siguiente forma: my regex nombre-regex { definición de la regex }
Para utilizar una regex, la invocamos con su nombre de esta forma: <nombre-regex>

MD5 es una función de cifrado de tipo hash que produce un valor hash de 128-bit.
MD5 tiene muchas aplicaciones, incluyendo el cifrado de contraseñas guardadas en una base de datos. Cuando se registra un nuevo usuario sus credenciales no se guardan en texto plano, se guardan cifradas, de forma que si un atacante compromete la base de datos, este atacante no podría conocer las contraseñas. Por suerte, no necesitas implementar el algoritmo MD5, pues ya lo implementa un módulo de Perl 6.

Vamos a instalarlo:
zef install Digest::MD5

Ahora, ejecutemos el siguiente script:

Para utilizar la función md5_hex() que produce el cifrado necesitaremos antes cargar el módulo requerido.
La palabra clave use carga el módulo para después utilizarlo en el script.

Las 3 líneas anteriores muestran formas distintas de construir un caracter:

La letra á puede escribirse:

NFC devuelve el número de código único.
NFD descompone el caracter y devuelve el número de código de cada parte.
uniname devuelve el nombre del número de código.

En condiciones normales todas las tareas de un programa se ejecutan de forma secuencial.
Esto no suele ser un problema, a menos que tarde demasiado tiempo.

Perl 6 te permite hacer cosas en paralelo.
Llegados aquí, es importante saber que el paralelismo puede tener dos significados:

Comencemos con la última.

Consideremos un programa en C con una función llamada holadesdec. Esta función visualiza Hola desde C en el terminal. No acepta argumentos ni devuelve ningún valor.

Dependiendo de tu sistema operativo, compila el código de C anterior en una librería de C.

En la misma carpeta donde has compilado la librería en C, crea un nuevo archivo de Perl 6 que contenga el siguiente código y ejecútalo.

Lo primero es declarar que vamos a utilizar el módulo NativeCall.
Después creamos la constante LIBPATH que contiene la ruta de la librería de C.
Como puedes ver, $*CWD contiene la ruta de la carpeta actual.
Después creamos una subrutina de Perl 6 denominada holadesdec() que se corresponde y tiene el mismo nombre que la función que reside en la librería de C, la cual se encuentra en LIBPATH.
Todo esto se hace utilizando is native.
Por último realizamos la llamada a la subrutina de Perl 6.

En esencia, todo se reduce a declarar una subrutina con is native y el nombre de la biblioteca de C.

Hemos visto cómo realizar una llamada a una función simple de C mediante una subrutina de Perl 6 con el mismo nombre y utilizando is native.

Es posible que en algunos casos necesitemos que el nombre de la función de Perl 6 sea distinto al de la función en C.
Para hacerlo utilizamos is symbol.

Vamos a modificar el script de Perl 6 que hemos visto de forma que la función de Perl 6 se llame hola en lugar de holadesdec.

En caso de que la subrutina de Perl 6 tenga un nombre distinto al de la función de C correspondiente, utilizamos is symbol con el nombre de la función de C original.

Vamos a modificar y compilar la librería de C y el script de Perl 6 de forma que acepten, en C un argumento de tipo char* y el mismo argumento en Perl 6 pero de tipo Str.

Vamos a repetir el proceso una vez más para crear una calculadora simple que toma dos enteros, los suma, devuelve el resultado y lo visualiza.
Compilamos la librería de C y ejecutamos el script de Perl 6.

Como puedes ver, ambas funciones aceptan dos enteros y devuelven uno (int en C y int32 en Perl 6).

Te preguntarás por qué en el script de Perl 6 utilizamos int32 en lugar de int.
En Perl 6 no pueden utilizarse algunos tipos como Int, Rat, etc. para pasarlos y recibirlos como valores de una función de C.
En Perl 6 hay que utilizar los mismos tipos que en C.

Por fortuna, Perl 6 proporciona muchos tipos que se corresponden con los de C.