Merge pull request #3953 from sumanstats/master

[language/raku-code] Perl6 to Raku and many more

2 files changed, 262 insertions, 262 deletions

diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
index 644182ff..76e9b6e6 100644
--- a/es-es/perl-es.html.markdown
+++ b/es-es/perl-es.html.markdown
@@ -11,9 +11,9 @@ translators:
 lang: es-es
 ---
 
-Perl 5 es un lenguaje de programación altamente capaz, rico en características, con más de 25 años de desarrollo.
+Perl es un lenguaje de programación altamente capaz, rico en características, con más de 25 años de desarrollo.
 
-Perl 5 corre en más de 100 plataformas, desde portátiles hasta ordenadores centrales, y es adecuado para realizar desde prototipos rápidos hasta desarrollar proyectos a gran escala.
+Perl corre en más de 100 plataformas, desde portátiles hasta ordenadores centrales, y es adecuado para realizar desde prototipos rápidos hasta desarrollar proyectos a gran escala.
 
 ```perl
 # Comentarios de una sola línea con un carácter hash
@@ -31,7 +31,7 @@ Perl 5 corre en más de 100 plataformas, desde portátiles hasta ordenadores cen
 my $animal    = "camello";
 my $respuesta = 42;
 
-# Los valores escalares pueden ser cadenas de caracteres, números enteros o 
+# Los valores escalares pueden ser cadenas de caracteres, números enteros o
 # de punto flotante; Perl automáticamente los convertirá como sea requerido
 
 ## Arreglos
@@ -52,7 +52,7 @@ my %color_fruta = (
 
 # Los escalares, arreglos y hashes están más documentados en perldata (perldoc perldata)
 
-# Los tipos de datos más complejos se pueden construir utilizando 
+# Los tipos de datos más complejos se pueden construir utilizando
 # referencias, las cuales le permiten construir listas y hashes dentro
 # de listas y hashes
 
@@ -61,7 +61,7 @@ my %color_fruta = (
 # Perl tiene la mayoría de las estructuras condicionales y de ciclos más comunes
 if ( $var ) {
     ...;
-} elsif ( $var eq 'bar' ) { 
+} elsif ( $var eq 'bar' ) {
     ...;
 } else {
     ...;
@@ -98,7 +98,7 @@ foreach (@array) {
 
 #### Expresiones regulares
 
-# El soporte de expresiones regulares en Perl es muy amplio y profundo, y 
+# El soporte de expresiones regulares en Perl es muy amplio y profundo, y
 # está sujeto a una extensa documentación en perlrequick, perlretut, entre otros.
 # Sin embargo, resumiendo:
 
@@ -113,7 +113,7 @@ $a =~ s/foo/bar/g;        # remplaza TODAS LAS INSTANCIAS de "foo" con "bar" en
 
 #### Archivos y E/S
 
-# Puede abrir un archivo para obtener datos o escribirlos utilizando la 
+# Puede abrir un archivo para obtener datos o escribirlos utilizando la
 # función "open()"
 
 open(my $entrada, "<"  "entrada.txt") or die "No es posible abrir entrada.txt: $!";
@@ -122,7 +122,7 @@ open(my $log,     ">>", "mi.log")     or die "No es posible abrir mi.log: $!";
 
 # Es posible leer desde un gestor de archivo abierto utilizando el operador "<>".
 # En contexto escalar, leer una sola línea desde el gestor de archivo, y
-# en contexto de lista, leer el archivo completo en donde asigna 
+# en contexto de lista, leer el archivo completo en donde asigna
 # cada línea a un elemento de la lista
 
 my $linea  = <$entrada>;
diff --git a/es-es/perl6-es.html.markdown b/es-es/raku-es.html.markdown
index bf3ae65e..e916d0fd 100644
--- a/es-es/perl6-es.html.markdown
+++ b/es-es/raku-es.html.markdown
@@ -1,8 +1,8 @@
 ---
 name: perl6
 category: language
-language: perl6
-filename: perl6-es.p6
+language: Raku
+filename: learnraku-es.raku
 contributors:
     - ["vendethiel", "http://github.com/vendethiel"]
     - ["Samantha McVey", "https://cry.nu"]
@@ -11,10 +11,10 @@ translators:
 lang: es-es
 ---
 
-Perl 6 es un lenguaje de programación altamente capaz y con características 
+Raku es un lenguaje de programación altamente capaz y con características
 abundantes para hacerlo el lenguage ideal por los próximos 100 años.
 
-El compilador primario de Perl 6 se llama [Rakudo](http://rakudo.org), el cual 
+El compilador primario de Raku se llama [Rakudo](http://rakudo.org), el cual
 se ejecuta en JVM y en [MoarVM](http://moarvm.com).
 
 Meta-nota: dos signos de números (##) son usados para indicar párrafos,
@@ -26,7 +26,7 @@ mientras que un solo signo de número (#) indica notas.
 # Un comentario de una sola línea comienza con un signo de número
 
 #`(
-  Comentarios multilíneas usan #` y signos de encerradura tales 
+  Comentarios multilíneas usan #` y signos de encerradura tales
   como (), [], {}, 「」, etc.
 )
 ```
@@ -34,28 +34,28 @@ mientras que un solo signo de número (#) indica notas.
 ## Variables
 
 ```perl6
-## En Perl 6, se declara una variable lexical usando `my`
+## En Raku, se declara una variable lexical usando `my`
 my $variable;
-## Perl 6 tiene 3 tipos básicos de variables: escalares, arrays, y hashes.
+## Raku tiene 3 tipos básicos de variables: escalares, arrays, y hashes.
 ```
 
 ### Escalares
 
 ```perl6
-# Un escalar representa un solo valor. Variables escalares comienzan 
+# Un escalar representa un solo valor. Variables escalares comienzan
 # con un `$`
 
 my $str = 'Cadena';
-# Las comillas inglesas ("") permiten la intepolación (lo cual veremos 
+# Las comillas inglesas ("") permiten la intepolación (lo cual veremos
 # luego):
 my $str2 = "Cadena";
 
 ## Los nombres de variables pueden contener pero no terminar con comillas
-## simples y guiones. Sin embargo, pueden contener 
+## simples y guiones. Sin embargo, pueden contener
 ## (y terminar con) guiones bajos (_):
 my $nombre'de-variable_ = 5; # Esto funciona!
 
-my $booleano = True; # `True` y `False` son valores booleanos en Perl 6.
+my $booleano = True; # `True` y `False` son valores booleanos en Raku.
 my $inverso = !$booleano; # Puedes invertir un booleano con el operador prefijo `!`
 my $bool-forzado = so $str; # Y puedes usar el operador prefijo `so` que
 						   # convierte su operador en un Bool
@@ -70,7 +70,7 @@ my $bool-forzado = so $str; # Y puedes usar el operador prefijo `so` que
 my @array = 'a', 'b', 'c';
 # equivalente a:
 my @letras = <a b c>;  # array de palabras, delimitado por espacios.
-                       # Similar al qw de perl5, o el %w de Ruby.
+                       # Similar al qw de perl, o el %w de Ruby.
 my @array = 1, 2, 3;
 
 say @array[2]; # Los índices de un array empiezan por el 0 -- Este es
@@ -83,7 +83,7 @@ say "Interpola todos los elementos de un array usando [] : @array[]";
 @array[0, 1] = 5, 6; # Asigna varios valores
 
 my @llaves = 0, 2;
-@array[@llaves] = @letras; # Asignación usando un array que contiene valores 
+@array[@llaves] = @letras; # Asignación usando un array que contiene valores
 						   # índices
 say @array; #=> a 6 b
 ```
@@ -93,19 +93,19 @@ say @array; #=> a 6 b
 ```perl6
 ## Un hash contiene parejas de llaves y valores.
 ## Puedes construir un objeto Pair usando la sintaxis `LLave => Valor`.
-## Tablas de hashes son bien rápidas para búsqueda, y son almacenadas 
+## Tablas de hashes son bien rápidas para búsqueda, y son almacenadas
 ## sin ningún orden.
 ## Ten en cuenta que las llaves son "aplanadas" en contexto de hash, y
 ## cualquier llave duplicada es deduplicada.
 my %hash = 1 => 2,
            3 => 4;
-my %hash = foo => "bar", 			 # las llaves reciben sus comillas 
+my %hash = foo => "bar", 			 # las llaves reciben sus comillas
                                      # automáticamente.
            "some other" => "value", # las comas colgantes estań bien.
            ;
 
 ## Aunque los hashes son almacenados internamente de forma diferente a los
-## arrays, Perl 6 te permite crear un hash usando un array
+## arrays, Raku te permite crear un hash usando un array
 ## con un número par de elementos fácilmente.
 my %hash = <llave1 valor1 llave2 valor2>;
 
@@ -122,7 +122,7 @@ my %hash = :w(1),    # equivalente a `w => 1`
 
 say %hash{'llave1'}; # Puedes usar {} para obtener el valor de una llave
 say %hash<llave2>;   # Si es una cadena de texto, puedes actualmente usar <>
-                     # (`{llave1}` no funciona, debido a que Perl 6 no tiene
+                     # (`{llave1}` no funciona, debido a que Raku no tiene
                      # palabras desnudas (barewords en inglés))
 ```
 
@@ -133,7 +133,7 @@ say %hash<llave2>;   # Si es una cadena de texto, puedes actualmente usar <>
 ## creadas con la palabra clave `sub`.
 sub di-hola { say "¡Hola, mundo!" }
 
-## Puedes proveer argumentos (tipados). Si especificado, 
+## Puedes proveer argumentos (tipados). Si especificado,
 ## el tipo será chequeado al tiempo de compilación si es posible.
 ## De lo contrario, al tiempo de ejecución.
 sub di-hola-a(Str $nombre) {
@@ -165,7 +165,7 @@ say return-for; # imprime Nil
 
 ## Una subrutina puede tener argumentos opcionales:
 sub con-opcional($arg?) { # el signo "?" marca el argumento opcional
-  say "Podría returnar `(Any)` (valor de Perl parecido al 'null') si no me pasan 
+  say "Podría returnar `(Any)` (valor de Perl parecido al 'null') si no me pasan
 		un argumento, o returnaré mi argumento";
   $arg;
 }
@@ -173,7 +173,7 @@ con-opcional;    # devuelve Any
 con-opcional();  # devuelve Any
 con-opcional(1); # devuelve 1
 
-## También puedes proveer un argumento por defecto para 
+## También puedes proveer un argumento por defecto para
 ## cuando los argumentos no son proveídos:
 sub hola-a($nombre = "Mundo") {
   say "¡Hola, $nombre!";
@@ -190,10 +190,10 @@ sub con-nombre($arg-normal, :$nombrado) {
 }
 con-nombre(1, nombrado => 6); #=> 7
 ## Sin embargo, debes tener algo en cuenta aquí:
-## Si pones comillas alrededor de tu llave, Perl 6 no será capaz de verla
+## Si pones comillas alrededor de tu llave, Raku no será capaz de verla
 ## al tiempo de compilación, y entonces tendrás un solo objeto Pair como
-## un argumento posicional, lo que significa que el siguiente ejemplo 
-## falla: 
+## un argumento posicional, lo que significa que el siguiente ejemplo
+## falla:
 con-nombre(1, 'nombrado' => 6);
 
 con-nombre(2, :nombrado(5)); #=> 7
@@ -205,7 +205,7 @@ sub con-nombre-mandatorio(:$str!)  {
 }
 con-nombre-mandatorio(str => "Mi texto"); #=> Mi texto!
 con-nombre-mandatorio;   # error al tiempo de ejecución:
-						 # "Required named parameter not passed" 
+						 # "Required named parameter not passed"
 						 # ("Parámetro nombrado requerido no proveído")
 con-nombre-mandatorio(3);# error al tiempo de ejecución:
 						 # "Too many positional parameters passed"
@@ -226,7 +226,7 @@ sub nombrado-definido(:$def = 5) {
 nombrado-definido; #=> 5
 nombrado-definido(def => 15); #=> 15
 
-## Dado que puedes omitir los paréntesis para invocar una función sin 
+## Dado que puedes omitir los paréntesis para invocar una función sin
 ## argumentos, necesitas usar "&" en el nombre para almacenar la función
 ## `di-hola` en una variable.
 my &s = &di-hola;
@@ -240,8 +240,8 @@ sub muchos($principal, *@resto) {  #`*@` (slurpy) consumirá lo restante
   say @resto.join(' / ') ~ "!";
 }
 say muchos('Feliz', 'Cumpleaño', 'Cumpleaño'); #=> Feliz / Cumpleaño!
-                                           # Nota que el asterisco (*) no 
-                                           # consumió el parámetro frontal. 
+                                           # Nota que el asterisco (*) no
+                                           # consumió el parámetro frontal.
 
 ## Puedes invocar un función con un array usando el
 ## operador "aplanador de lista de argumento" `|`
@@ -256,12 +256,12 @@ concat3(|@array); #=> a, b, c
 ## Contenedores
 
 ```perl6
-## En Perl 6, valores son actualmente almacenados en "contenedores".
-## El operador de asignación le pregunta al contenedor en su izquierda 
+## En Raku, valores son actualmente almacenados en "contenedores".
+## El operador de asignación le pregunta al contenedor en su izquierda
 ## almacenar el valor a su derecha. Cuando se pasan alrededor, contenedores
 ## son marcados como inmutables. Esto significa que, en una función, tu
 ## tendrás un error si tratas de mutar uno de tus argumentos.
-## Si realmente necesitas hacerlo, puedes preguntar por un contenedor 
+## Si realmente necesitas hacerlo, puedes preguntar por un contenedor
 ## mutable usando `is rw`:
 sub mutar($n is rw) {
   $n++;
@@ -276,7 +276,7 @@ mutar $m; # ¡$n es ahora 43!
 ## dado que no contenedor ha sido pasado y números enteros son inmutables
 ## por naturaleza:
 
-mutar 42; # Parámetro '$n' esperaba un contenedor mutable, 
+mutar 42; # Parámetro '$n' esperaba un contenedor mutable,
 		  # pero recibió un valor Int
 
 ## Si en cambio quieres una copia, debes usar `is copy`.
@@ -286,7 +286,7 @@ mutar 42; # Parámetro '$n' esperaba un contenedor mutable,
 my $x = 42;
 sub x-almacena() is rw { $x }
 x-almacena() = 52; # En este caso, los paréntesis son mandatorios
-                # (porque de otra forma, Perl 6 piensa que la función
+                # (porque de otra forma, Raku piensa que la función
 				# `x-almacena` es un identificador).
 say $x; #=> 52
 ```
@@ -297,9 +297,9 @@ say $x; #=> 52
 ```perl6
 ## - `if`
 ## Antes de hablar acerca de `if`, necesitamos saber cuales valores son
-## "Truthy" (representa True (verdadero)), y cuales son "Falsey" 
-## (o "Falsy") -- representa False (falso). Solo estos valores son 
-## Falsey: 0, (), {}, "", Nil, un tipo (como `Str` o`Int`) y 
+## "Truthy" (representa True (verdadero)), y cuales son "Falsey"
+## (o "Falsy") -- representa False (falso). Solo estos valores son
+## Falsey: 0, (), {}, "", Nil, un tipo (como `Str` o`Int`) y
 ## por supuesto False. Todos los valores son Truthy.
 if True {
   say "¡Es verdadero!";
@@ -316,8 +316,8 @@ unless False {
 ## También puedes usar sus versiones sufijos seguidas por la palabra clave:
 say "Un poco verdadero" if True;
 
-## - La condicional ternaria, "?? !!" (como `x ? y : z` en otros lenguajes) 
-##   devuelve $valor-si-verdadera si la condición es verdadera y 
+## - La condicional ternaria, "?? !!" (como `x ? y : z` en otros lenguajes)
+##   devuelve $valor-si-verdadera si la condición es verdadera y
 ##   $valor-si-falsa si es falsa.
 ##   my $resultado = $valor condición ?? $valor-si-verdadera !! $valor-si-falsa;
 
@@ -338,21 +338,21 @@ say $edad > 18 ?? "Eres un adulto" !! "Eres menor de 18";
 ##
 ## `given` simplemente pone su argumento en `$_` (como un bloque lo haría),
 ## y `when` lo compara usando el operador de "coincidencia inteligente" (`~~`).
-## 
-## Dado que otras construcciones de Perl 6 usan esta variable (por ejemplo,
+##
+## Dado que otras construcciones de Raku usan esta variable (por ejemplo,
 ## el bucle `for`, bloques, etc), esto se significa que el poderoso `when` no
-## solo se aplica con un `given`, sino que se puede usar en cualquier 
+## solo se aplica con un `given`, sino que se puede usar en cualquier
 ## lugar donde exista una variable `$_`.
 
 given "foo bar" {
   say $_; #=> foo bar
-  when /foo/ { # No te preocupies acerca de la coincidencia inteligente – 
+  when /foo/ { # No te preocupies acerca de la coincidencia inteligente –
 			   # solo ten presente que `when` la usa.
                # Esto es equivalente a `if $_ ~~ /foo/`.
     say "¡Yay!";
   }
   when $_.chars > 50 { # coincidencia inteligente con cualquier cosa True es True,
-                       # i.e. (`$a ~~ True`) 
+                       # i.e. (`$a ~~ True`)
                        # por lo tanto puedes también poner condiciones "normales".
                        # Este `when` es equivalente a este `if`:
                        #  if $_ ~~ ($_.chars > 50) {...}
@@ -373,12 +373,12 @@ given "foo bar" {
 ## pero también puede ser un bucle for al estilo de C:
 loop {
   say "¡Este es un bucle infinito!";
-  last; # last interrumpe el bucle, como la palabra clave `break` 
+  last; # last interrumpe el bucle, como la palabra clave `break`
         # en otros lenguajes.
 }
 
 loop (my $i = 0; $i < 5; $i++) {
-  next if $i == 3;  # `next` salta a la siguiente iteración, al igual 
+  next if $i == 3;  # `next` salta a la siguiente iteración, al igual
 					 # que `continue` en otros lenguajes. Ten en cuenta que
 					 # también puedes usar la condicionales postfix (sufijas)
                      # bucles, etc.
@@ -391,29 +391,29 @@ for @array -> $variable {
 }
 
 ## Como vimos con `given`, la variable de una "iteración actual" por defecto
-## es `$_`. Esto significa que puedes usar `when` en un bucle `for` como 
+## es `$_`. Esto significa que puedes usar `when` en un bucle `for` como
 ## normalmente lo harías con `given`.
 for @array {
   say "he conseguido a $_";
 
   .say; # Esto es también permitido.
-        # Una invocación con punto (dot call) sin "tópico" (recibidor) es 
-		# enviada a `$_` por defecto. 
+        # Una invocación con punto (dot call) sin "tópico" (recibidor) es
+		# enviada a `$_` por defecto.
   $_.say; # lo mismo de arriba, lo cual es equivalente.
 }
 
 for @array {
   # Puedes...
-  next if $_ == 3; # Saltar a la siguiente iteración (`continue` en 
+  next if $_ == 3; # Saltar a la siguiente iteración (`continue` en
 				   # lenguages parecido a C)
-  redo if $_ == 4; # Re-hacer la iteración, manteniendo la 
+  redo if $_ == 4; # Re-hacer la iteración, manteniendo la
 				   # misma variable tópica (`$_`)
-  last if $_ == 5; # Salir fuera del bucle (como `break` 
+  last if $_ == 5; # Salir fuera del bucle (como `break`
 				   # en lenguages parecido a C)
 }
 
-## La sintaxis de "bloque puntiagudo" no es específica al bucle for. 
-## Es solo una manera de expresar un bloque en Perl 6.
+## La sintaxis de "bloque puntiagudo" no es específica al bucle for.
+## Es solo una manera de expresar un bloque en Raku.
 if computación-larga() -> $resultado {
   say "El resultado es $resultado";
 }
@@ -423,7 +423,7 @@ if computación-larga() -> $resultado {
 
 ```perl6
 ## Dados que los lenguajes de la familia Perl son lenguages basados
-## mayormente en operadores, los operadores de Perl 6 son actualmente 
+## mayormente en operadores, los operadores de Raku son actualmente
 ## subrutinas un poco cómicas en las categorías sintácticas. Por ejemplo,
 ## infix:<+> (adición) o prefix:<!> (bool not).
 
@@ -455,7 +455,7 @@ if computación-larga() -> $resultado {
 (1, 2) eqv (1, 3);
 
 ## - Operador de coincidencia inteligente (smart matching): `~~`
-## Asocia (aliasing en inglés) el lado izquierda a la variable $_ 
+## Asocia (aliasing en inglés) el lado izquierda a la variable $_
 ## y después evalúa el lado derecho.
 ## Aquí algunas comparaciones semánticas comunes:
 
@@ -464,8 +464,8 @@ if computación-larga() -> $resultado {
 'Foo' ~~ 'Foo'; # True si las cadenas de texto son iguales.
 12.5 ~~ 12.50; # True si los números son iguales.
 
-## Regex - Para la comparación de una expresión regular en contra 
-## del lado izquierdo. Devuelve un objeto (Match), el cual evalúa 
+## Regex - Para la comparación de una expresión regular en contra
+## del lado izquierdo. Devuelve un objeto (Match), el cual evalúa
 ## como True si el regex coincide con el patrón.
 
 my $obj = 'abc' ~~ /a/;
@@ -475,12 +475,12 @@ say $obj.WHAT; # (Match)
 ## Hashes
 'llave' ~~ %hash; # True si la llave existe en el hash
 
-## Tipo - Chequea si el lado izquierdo "tiene un tipo" (puede chequear 
+## Tipo - Chequea si el lado izquierdo "tiene un tipo" (puede chequear
 ## superclases y roles)
 
 1 ~~ Int; # True (1 es un número entero)
 
-## Coincidencia inteligente contra un booleano siempre devuelve ese 
+## Coincidencia inteligente contra un booleano siempre devuelve ese
 ## booleano (y lanzará una advertencia).
 
 1 ~~ True; # True
@@ -502,13 +502,13 @@ False ~~ True; # True
 ## Esto también funciona como un atajo para `0..^N`:
 ^10; # significa 0..^10
 
-## Esto también nos permite demostrar que Perl 6 tiene arrays 
+## Esto también nos permite demostrar que Raku tiene arrays
 ## ociosos/infinitos, usando la Whatever Star:
 my @array = 1..*; # 1 al Infinito! `1..Inf` es lo mismo.
 say @array[^10]; # puedes pasar arrays como subíndices y devolverá
    				 # un array de resultados. Esto imprimirá
 				 # "1 2 3 4 5 6 7 8 9 10" (y no se quedaré sin memoria!)
-## Nota: Al leer una lista infinita, Perl 6 "cosificará" los elementos que
+## Nota: Al leer una lista infinita, Raku "cosificará" los elementos que
 ## necesita y los mantendrá en la memoria. Ellos no serán calculados más de
 ## una vez. Tampoco calculará más elementos de los que necesita.
 
@@ -517,14 +517,14 @@ say @array[^10]; # puedes pasar arrays como subíndices y devolverá
 say join(' ', @array[15..*]); #=> 15 16 17 18 19
 ## lo que es equivalente a:
 say join(' ', @array[-> $n { 15..$n }]);
-## Nota: Si tratas de hacer cualquiera de esos con un array infinito, 
+## Nota: Si tratas de hacer cualquiera de esos con un array infinito,
 ##		  provocará un array infinito (tu programa nunca terminará)
 
 ## Puedes usar eso en los lugares que esperaría, como durante la asignación
 ## a un array
 my @números = ^20;
 
-## Aquí los números son incrementados por "6"; más acerca del 
+## Aquí los números son incrementados por "6"; más acerca del
 ## operador `...` adelante.
 my @seq =  3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99;
 @números[5..*] = 3, 9 ... *; # aunque la secuencia es infinita,
@@ -546,7 +546,7 @@ $a && $b && $c; # Devuelve 0, el primer valor que es False
 $b || $a; # 1
 
 ## Y porque tu lo querrás, también tienes operadores de asignación
-## compuestos: 
+## compuestos:
 $a *= 2;  # multiplica y asigna. Equivalente a $a = $a * 2;
 $b %%= 5; # divisible por y asignación. Equivalente $b = $b %% 5;
 @array .= sort; # invoca el método `sort` y asigna el resultado devuelto.
@@ -555,8 +555,8 @@ $b %%= 5; # divisible por y asignación. Equivalente $b = $b %% 5;
 ## ¡Más sobre subrutinas!
 
 ```perl6
-## Como dijimos anteriormente, Perl 6 tiene subrutinas realmente poderosas.
-## Veremos unos conceptos claves que la hacen mejores que en cualquier otro 
+## Como dijimos anteriormente, Raku tiene subrutinas realmente poderosas.
+## Veremos unos conceptos claves que la hacen mejores que en cualquier otro
 ## lenguaje :-).
 ```
 
@@ -602,14 +602,14 @@ sub fst(*@ [$fst]) { # o simplemente: `sub fst($fst) { ... }`
 fst(1); #=> 1
 fst(1, 2); # errores con "Too many positional parameters passed"
 
-## También puedes desestructurar hashes (y clases, las cuales 
-## veremos adelante). La sintaxis es básicamente 
+## También puedes desestructurar hashes (y clases, las cuales
+## veremos adelante). La sintaxis es básicamente
 ## `%nombre-del-hash (:llave($variable-para-almacenar))`.
 ## El hash puede permanecer anónimos si solo necesitas los valores extraídos.
 sub llave-de(% (:azul($val1), :red($val2))) {
   say "Valores: $val1, $val2.";
 }
-## Después invócala con un hash: (necesitas mantener las llaves 
+## Después invócala con un hash: (necesitas mantener las llaves
 ## de los parejas de llave y valor para ser un hash)
 llave-de({azul => 'blue', rojo => "red"});
 #llave-de(%hash); # lo mismo (para un `%hash` equivalente)
@@ -621,11 +621,11 @@ sub siguiente-indice($n) {
 }
 my $nuevo-n= siguiente-indice(3); # $nuevo-n es ahora 4
 
-## Este es cierto para todo, excepto para las construcciones de bucles 
+## Este es cierto para todo, excepto para las construcciones de bucles
 ## (debido a razones de rendimiento): Hay una razón de construir una lista
 ## si la vamos a desechar todos los resultados.
 ## Si todavías quieres construir una, puedes usar la sentencia prefijo `do`:
-## (o el prefijo `gather`, el cual veremos luego) 
+## (o el prefijo `gather`, el cual veremos luego)
 sub lista-de($n) {
   do for ^$n { # nota el uso del operador de rango `^` (`0..^N`)
     $_        # iteración de bucle actual
@@ -639,19 +639,19 @@ my @list3 = lista-de(3); #=> (0, 1, 2)
 ```perl6
 ## Puedes crear una lambda con `-> {}` ("bloque puntiagudo") o `{}` ("bloque")
 my &lambda = -> $argumento { "El argumento pasado a esta lambda es $argumento" }
-## `-> {}` y `{}` son casi la misma cosa, excepto que la primerra puede 
+## `-> {}` y `{}` son casi la misma cosa, excepto que la primerra puede
 ## tomar argumentos, y la segunda puede ser malinterpretada como un hash
 ## por el parseador.
 
 ## Podemos, por ejemplo, agregar 3  a cada valor de un array usando map:
 my @arraymas3 = map({ $_ + 3 }, @array); # $_ es el argumento implícito
 
-## Una subrutina (`sub {}`) tiene semánticas diferentes a un 
-## bloque (`{}` or `-> {}`): Un bloque no tiene "contexto funcional" 
+## Una subrutina (`sub {}`) tiene semánticas diferentes a un
+## bloque (`{}` or `-> {}`): Un bloque no tiene "contexto funcional"
 ## (aunque puede tener argumentos), lo que significa que si quieres devolver
 ## algo desde un bloque, vas a returnar desde la función parental. Compara:  
 sub is-in(@array, $elem) {
-  # esto `devolverá` desde la subrutina `is-in` 
+  # esto `devolverá` desde la subrutina `is-in`
   # Una vez que la condición evalúa a True, el bucle terminará
   map({ return True if $_ == $elem }, @array);
 }
@@ -685,7 +685,7 @@ map(sub ($a, $b) { $a + $b + 3 }, @array); # (aquí con `sub`)
 ### Acerca de tipos...
 
 ```perl6
-## Perl 6 es gradualmente tipado. Esto quiere decir que tu especifica el 
+## Raku es gradualmente tipado. Esto quiere decir que tu especifica el
 ## tipo de tus variables/argumentos/devoluciones (return), o puedes omitirlos
 ## y serán "Any" por defecto.
 ## Obviamente tienes acceso a algunas tipos básicos, como Int y Str.
@@ -703,7 +703,7 @@ subset EnteroGrande of Int where * > 500;
 ### Despacho Múltiple (Multiple Dispatch)
 
 ```perl6
-## Perl 6 puede decidir que variante de una subrutina invocar basado en el 
+## Raku puede decidir que variante de una subrutina invocar basado en el
 ## tipo de los argumento, o precondiciones arbitrarias, como con un tipo o
 ## un `where`:
 
@@ -740,9 +740,9 @@ multi sin_ti-o-contigo {
 }
 ## Esto es muy útil para muchos propósitos, como subrutinas `MAIN` (de las
 ## cuales hablaremos luego), y hasta el mismo lenguaje la está usando
-## en muchos lugares. 
+## en muchos lugares.
 ##
-## - `is`, por ejemplo, es actualmente un `multi sub` llamado 
+## - `is`, por ejemplo, es actualmente un `multi sub` llamado
 ##	`trait_mod:<is>`.
 ## - `is rw`, es simplemente un despacho a una función con esta signatura:
 ## sub trait_mod:<is>(Routine $r, :$rw!) {}
@@ -754,7 +754,7 @@ multi sin_ti-o-contigo {
 ## Ámbito (Scoping)
 
 ```perl6
-## En Perl 6, a diferencia de otros lenguajes de scripting, (tales como
+## En Raku, a diferencia de otros lenguajes de scripting, (tales como
 ## (Python, Ruby, PHP), debes declarar tus variables antes de usarlas. El
 ## declarador `my`, del cual aprendiste anteriormente, usa "ámbito léxical".
 ## Hay otros declaradores (`our`, `state`, ..., ) los cuales veremos luego.
@@ -770,7 +770,7 @@ sub externo {
 }
 outer()(); #=> 'Foo Bar'
 
-## Como puedes ver, `$archivo-en-ámbito` y `$ámbito-externo` 
+## Como puedes ver, `$archivo-en-ámbito` y `$ámbito-externo`
 ## fueron capturados. Pero si intentaramos usar `$bar` fuera de `foo`,
 ## la variable estaría indefinida (y obtendrías un error al tiempo de
 ## compilación).
@@ -779,12 +779,12 @@ outer()(); #=> 'Foo Bar'
 ## Twigils
 
 ```perl6
-## Hay muchos `twigils` especiales (sigilos compuestos) en Perl 6. 
-## Los twigils definen el ámbito de las variables. 
+## Hay muchos `twigils` especiales (sigilos compuestos) en Raku.
+## Los twigils definen el ámbito de las variables.
 ## Los twigils * y ? funcionan con variables regulares:
 ## * Variable dinámica
 ## ? Variable al tiempo de compilación
-## Los twigils ! y . son usados con los objetos de Perl 6:
+## Los twigils ! y . son usados con los objetos de Raku:
 ## ! Atributo (miembro de la clase)
 ## . Método (no una variable realmente)
 
@@ -820,20 +820,20 @@ di_ambito(); #=> 1 100 Cambiamos el valor de $*ambito_din_2 en invoca_a_di_ambit
 
 ```perl6
 ## Para invocar a un método en un objeto, agrega un punto seguido por el
-## nombre del objeto: 
+## nombre del objeto:
 ## => $object.method
 ## Las classes son declaradas usando la palabra clave `class`. Los atributos
 ## son declarados con la palabra clave `has`, y los métodos con `method`.
 ## Cada atributo que es privado usa el twigil `!`. Por ejemplo: `$!attr`.
-## Atributos públicos inmutables usan el twigil `.` (los puedes hacer 
+## Atributos públicos inmutables usan el twigil `.` (los puedes hacer
 ## mutables con `is rw`).
-## La manera más fácil de recordar el twigil `$.` is comparándolo 
+## La manera más fácil de recordar el twigil `$.` is comparándolo
 ## con como los métodos son llamados.
 
-## El modelo de objeto de Perl 6 ("SixModel") es muy flexible, y te permite
+## El modelo de objeto de Raku ("SixModel") es muy flexible, y te permite
 ## agregar métodos dinámicamente, cambiar la semántica, etc ...
-## (no hablaremos de todo esto aquí. Por lo tanto, refiérete a: 
-## https://docs.perl6.org/language/objects.html).
+## (no hablaremos de todo esto aquí. Por lo tanto, refiérete a:
+## https://docs.raku.org/language/objects.html).
 
 class Clase-Atrib {
   has $.atrib; # `$.atrib` es inmutable.
@@ -858,7 +858,7 @@ class Clase-Atrib {
 };
 
 ## Crear una nueva instancia de Clase-Atrib con $.atrib asignado con 5:
-## Nota: No puedes asignarle un valor a atrib-privado desde aquí (más de 
+## Nota: No puedes asignarle un valor a atrib-privado desde aquí (más de
 ## esto adelante).
 my $class-obj = Clase-Atrib.new(atrib => 5);
 say $class-obj.devolver-valor; #=> 5
@@ -870,12 +870,12 @@ $class-obj.otro-atrib = 10; # En cambio, esto funciona porque el atributo
 ### Herencia de Objeto
 
 ```perl6
-## Perl 6 también tiene herencia (junto a herencia múltiple)
+## Raku también tiene herencia (junto a herencia múltiple)
 ## Mientras los métodos declarados con `method` son heredados, aquellos
 ## declarados con `submethod` no lo son.
 ## Submétodos son útiles para la construcción y destrucción de tareas,
 ## tales como BUILD, o métodos que deben ser anulados por subtipos.
-## Aprenderemos acerca de BUILD más adelante. 
+## Aprenderemos acerca de BUILD más adelante.
 
 class Padre {
   has $.edad;
@@ -890,7 +890,7 @@ class Padre {
 # Herencia usa la palabra clave `is`
 class Niño is Padre {
   method hablar { say "Goo goo ga ga" }
-  # Este método opaca el método `hablar` de Padre. 
+  # Este método opaca el método `hablar` de Padre.
   # Este niño no ha aprendido a hablar todavía.
 }
 my Padre $Richard .= new(edad => 40, nombre => 'Richard');
@@ -899,19 +899,19 @@ $Richard.hablar; #=> "Hola, mi nombre es Richard"
 ## $Richard es capaz de acceder el submétodo; él sabe como decir su nombre.
 
 my Niño $Madison .= new(edad => 1, nombre => 'Madison');
-$Madison.hablar; # imprime "Goo goo ga ga" dado que el método fue cambiado 
+$Madison.hablar; # imprime "Goo goo ga ga" dado que el método fue cambiado
 				 # en la clase Niño.
 # $Madison.color-favorito # no funciona porque no es heredado
 
 ## Cuando se usa `my T $var` (donde `T` es el nombre de la clase), `$var`
 ## inicia con `T` en si misma, por lo tanto puedes invocar `new` en `$var`.
-## (`.=` es sólo la invocación por punto y el operador de asignación: 
+## (`.=` es sólo la invocación por punto y el operador de asignación:
 ## `$a .= b` es lo mismo que `$a = $a.b`)
 ## Por ejemplo, la instancia $Richard pudo también haber sido declarada así:
 ## my $Richard = Padre.new(edad => 40, nombre => 'Richard');
 
-## También observa que `BUILD` (el método invocado dentro de `new`) 
-## asignará propiedades de la clase padre, por lo que puedes pasar 
+## También observa que `BUILD` (el método invocado dentro de `new`)
+## asignará propiedades de la clase padre, por lo que puedes pasar
 ## `val => 5`.
 ```
 
@@ -932,7 +932,7 @@ class Item does PrintableVal {
   has $.val;
 
   ## Cuando se utiliza `does`, un `rol` se mezcla en al clase literalmente:
-  ## los métodos y atributos se ponen juntos, lo que significa que una clase 
+  ## los métodos y atributos se ponen juntos, lo que significa que una clase
   ## puede acceder los métodos y atributos privados de su rol (pero no lo inverso!):
   method access {
     say $!counter++;
@@ -945,17 +945,17 @@ class Item does PrintableVal {
   ## de su clase hijo/a, pero es un error sin un rol lo hace)
 
   ## NOTA: Puedes usar un rol como una clase (con `is ROLE`). En este caso,
-  ##       métodos serán opacados, dado que el compilador considerará `ROLE` 
-  ##       como una clase. 
+  ##       métodos serán opacados, dado que el compilador considerará `ROLE`
+  ##       como una clase.
 }
 ```
 
 ## Excepciones
 
 ```perl6
-## Excepciones están construidas al tope de las clases, en el paquete 
+## Excepciones están construidas al tope de las clases, en el paquete
 ## `X` (como `X::IO`).
-## En Perl 6, excepciones son lanzadas automáticamente.
+## En Raku, excepciones son lanzadas automáticamente.
 open 'foo'; #=> Failed to open file foo: no such file or directory
 ## También imprimirá la línea donde el error fue lanzado y otra información
 ## concerniente al error.
@@ -966,16 +966,16 @@ die 'Error!'; #=> Error!
 ## O más explícitamente:
 die X::AdHoc.new(payload => 'Error!');
 
-## En Perl 6, `orelse` es similar al operador `or`, excepto que solamente
+## En Raku, `orelse` es similar al operador `or`, excepto que solamente
 ## coincide con variables indefinidas, en cambio de cualquier cosa
 ## que evalúa a falso.
-## Valores indefinidos incluyen: `Nil`, `Mu` y `Failure`, también como 
+## Valores indefinidos incluyen: `Nil`, `Mu` y `Failure`, también como
 ## `Int`, `Str` y otros tipos que no han sido inicializados a ningún valor
 ## todavía.
 ## Puedes chequear si algo está definido o no usando el método defined:
 my $no-inicializada;
 say $no-inicializada.defined; #=> False
-## Al usar `orelse`, se desarmará la excepción y creará un alias de dicho 
+## Al usar `orelse`, se desarmará la excepción y creará un alias de dicho
 ## fallo en $_
 ## Esto evitará que sea automáticamente manejado e imprima una marejada de
 ## mensajes de errores en la pantalla.
@@ -986,7 +986,7 @@ open 'foo' orelse say "Algo pasó {.exception}";
 open 'foo' orelse say "Algo pasó $_"; #=> Algo pasó
               #=>  Failed to open file foo: no such file or directory
 ## Ambos ejemplos anteriores funcionan pero en caso de que consigamos un
-## objeto desde el lado izquierdo que no es un fallo, probablemente 
+## objeto desde el lado izquierdo que no es un fallo, probablemente
 ## obtendremos una advertencia. Más abajo vemos como usar `try` y `CATCH`
 ## para ser más expecíficos con las excepciones que capturamos.
 ```
@@ -994,8 +994,8 @@ open 'foo' orelse say "Algo pasó $_"; #=> Algo pasó
 ### Usando `try` y `CATCH`
 
 ```perl6
-## Al usar `try` y `CATCH`, puedes contener y manejar excepciones sin 
-## interrumpir el resto del programa. `try` asignará la última excepción 
+## Al usar `try` y `CATCH`, puedes contener y manejar excepciones sin
+## interrumpir el resto del programa. `try` asignará la última excepción
 ## a la variable especial `$!`.
 ## Nota: Esto no tiene ninguna relación con las variables $!.
 
@@ -1003,12 +1003,12 @@ try open 'foo';
 say "Bueno, lo intenté! $!" if defined $!; #=> Bueno, lo intenté! Failed to open file
                                        #foo: no such file or directory
 ## Ahora, ¿qué debemos hacer si queremos más control sobre la excepción?
-## A diferencia de otros lenguajes, en Perl 6 se pone el bloque `CATCH`
+## A diferencia de otros lenguajes, en Raku se pone el bloque `CATCH`
 ## *dentro* del bloque a intentar (`try`). Similarmente como $_ fue asignada
 ## cuando 'disarmamos' la excepción con `orelse`, también usamos $_ en el
 ## bloque CATCH.
 ## Nota: ($! es solo asignada *después* del bloque `try`)
-## Por defecto, un bloque `try` tiene un bloque `CATCH` que captura 
+## Por defecto, un bloque `try` tiene un bloque `CATCH` que captura
 ## cualquier excepción (`CATCH { default {} }`).
 
 try { my $a = (0 %% 0);  CATCH { say "Algo pasó: $_" } }
@@ -1022,9 +1022,9 @@ try {
     when X::AdHoc { say "Error: $_" }
      #=>Error: Failed to open file /dir/foo: no such file or directory
 
-	## Cualquier otra excepción será levantada de nuevo, dado que no 
+	## Cualquier otra excepción será levantada de nuevo, dado que no
 	## tenemos un `default`.
-	## Básicamente, si un `when` 
+	## Básicamente, si un `when`
     ## Basically, if a `when` matches (or there's a `default`) marks the
 	  ## exception as
     ## "handled" so that it doesn't get re-thrown from the `CATCH`.
@@ -1032,14 +1032,14 @@ try {
   }
 }
 
-## En Perl 6, excepciones poseen ciertas sutilezas. Algunas 
-## subrutinas en Perl 6 devuelven un `Failure`, el cual es un tipo de 
+## En Raku, excepciones poseen ciertas sutilezas. Algunas
+## subrutinas en Raku devuelven un `Failure`, el cual es un tipo de
 ## "excepción no levantada". Ellas no son levantadas hasta que tu intentas
-## mirar a sus contenidos, a menos que invoques `.Bool`/`.defined` sobre 
+## mirar a sus contenidos, a menos que invoques `.Bool`/`.defined` sobre
 ## ellas - entonces, son manejadas.
 ## (el método `.handled` es `rw`, por lo que puedes marcarlo como `False`
 ## por ti mismo)
-## Puedes levantar un `Failure` usando `fail`. Nota que si el pragma 
+## Puedes levantar un `Failure` usando `fail`. Nota que si el pragma
 ## `use fatal` estás siendo utilizado, `fail` levantará una excepión (como
 ## `die`).
 fail "foo"; # No estamos intentando acceder el valor, por lo tanto no problema.
@@ -1053,27 +1053,27 @@ try {
 ## También hay otro tipo de excepción: Excepciones de control.
 ## Esas son excepciones "buenas", las cuales suceden cuando cambias el flujo
 ## de tu programa, usando operadores como `return`, `next` or `last`.
-## Puedes capturarlas con `CONTROL` (no lista un 100% en Rakudo todavía). 
+## Puedes capturarlas con `CONTROL` (no lista un 100% en Rakudo todavía).
 ```
 
 ## Paquetes
 
 ```perl6
-## Paquetes son una manera de reusar código. Paquetes son como 
-## "espacio de nombres" (namespaces en inglés), y cualquier elemento del 
+## Paquetes son una manera de reusar código. Paquetes son como
+## "espacio de nombres" (namespaces en inglés), y cualquier elemento del
 ## modelo seis (`module`, `role`, `class`, `grammar`, `subset` y `enum`)
-## son paquetes por ellos mismos. (Los paquetes son como el mínimo común 
+## son paquetes por ellos mismos. (Los paquetes son como el mínimo común
 ## denominador)
-## Los paquetes son importantes - especialmente dado que Perl es bien 
+## Los paquetes son importantes - especialmente dado que Perl es bien
 ## reconocido por CPAN, the Comprehensive Perl Archive Nertwork.
 
 ## Puedes usar un módulo (traer sus declaraciones al ámbito) con `use`
 use JSON::Tiny; # si intalaste Rakudo* o Panda, tendrás este módulo
 say from-json('[1]').perl; #=> [1]
 
-## A diferencia de Perl 5, no deberías declarar paquetes usando 
+## A diferencia de Perl, no deberías declarar paquetes usando
 ## la palabra clave `package`. En vez, usa `class Nombre::Paquete::Aquí;`
-## para declarar una clase, o si solamente quieres exportar 
+## para declarar una clase, o si solamente quieres exportar
 ## variables/subrutinas, puedes usar `module`.
 
 module Hello::World { # forma de llaves
@@ -1083,11 +1083,11 @@ module Hello::World { # forma de llaves
 }
 unit module Parse::Text; # forma de ámbito de archivo
 
-grammar Parse::Text::Grammar { # Una gramática (grammar en inglés) es un paquete, 
+grammar Parse::Text::Grammar { # Una gramática (grammar en inglés) es un paquete,
 							   # en el cual puedes usar `use`
 }                    # Aprenderás más acerca de gramáticas en la sección de regex
 
-## Como se dijo anteriormente, cualquier parte del modelo seis es también un 
+## Como se dijo anteriormente, cualquier parte del modelo seis es también un
 ## paquete. Dado que `JSON::Tiny` usa su propia clase `JSON::Tiny::Actions`,
 ## tu puedes usarla de la manera siguiente:
 my $acciones = JSON::Tiny::Actions.new;
@@ -1098,13 +1098,13 @@ my $acciones = JSON::Tiny::Actions.new;
 ## Declaradores
 
 ```perl6
-## En Perl 6, tu obtienes diferentes comportamientos basado en como declaras
+## En Raku, tu obtienes diferentes comportamientos basado en como declaras
 ## una variable.
 ## Ya has visto `my` y `has`, ahora exploraremos el resto.
 
 ## * las declaraciones `our` ocurren al tiempo `INIT` (ve "Phasers" más abajo)
 ## Es como `my`, pero también crea una variable paquete.
-## (Todas las cosas relacionadas con paquetes (`class`, `role`, etc) son 
+## (Todas las cosas relacionadas con paquetes (`class`, `role`, etc) son
 ## `our` por defecto)
 module Var::Incrementar {
   our $nuestra-var = 1; # Nota: No puedes colocar una restricción de tipo
@@ -1132,7 +1132,7 @@ Var::Incrementar::Inc; #=> 3 # Nota como el valor de $nuestra-var fue
 Var::Incrementar::no-disponible; #=> Could not find symbol '&no-disponible'
 
 ## * `constant` (ocurre al tiempo `BEGIN`)
-## Puedes usar la palabra clave `constant` para declarar una 
+## Puedes usar la palabra clave `constant` para declarar una
 ## variable/símbolo al tiempo de compilación:
 constant Pi = 3.14;
 constant $var = 1;
@@ -1151,11 +1151,11 @@ sub aleatorio-fijo {
 aleatorio-fijo for ^10; # imprimirá el mismo número 10 veces
 
 ## Nota, sin embargo, que ellas existen separadamente en diferentes contextos.
-## Si declaras una función con un `state` dentro de un bucle, recreará la 
+## Si declaras una función con un `state` dentro de un bucle, recreará la
 ## variable por cada iteración del bucle. Observa:
 for ^5 -> $a {
   sub foo {
-    state $valor = rand; # Esto imprimirá un valor diferente 
+    state $valor = rand; # Esto imprimirá un valor diferente
                          # por cada valor de `$a`
   }
   for ^5 -> $b {
@@ -1165,11 +1165,11 @@ for ^5 -> $a {
 }
 ```
 
-## Phasers 
+## Phasers
 
 ```perl6
-## Un phaser en Perl 6 es un bloque que ocurre a determinados puntos de tiempo
-## en tu programa. Se les llama phaser porque marca un cambio en la fase de 
+## Un phaser en Raku es un bloque que ocurre a determinados puntos de tiempo
+## en tu programa. Se les llama phaser porque marca un cambio en la fase de
 ## de tu programa. Por ejemplo, cuando el programa es compilado, un bucle
 ## for se ejecuta, dejas un bloque, o una excepción se levanta.
 ## (¡`CATCH` es actualmente un phaser!)
@@ -1191,13 +1191,13 @@ END { say "Se ejecuta al tiempo de ejecución, " ~
           "tan tarde como sea posible, una sola vez" }
 
 ## * Phasers de bloques
-ENTER { say "[*] Se ejecuta cada vez que entra en un bloque, " ~ 
+ENTER { say "[*] Se ejecuta cada vez que entra en un bloque, " ~
 		"se repite en bloques de bucle" }
-LEAVE { say "Se ejecuta cada vez que abandona un bloque, incluyendo " ~ 
+LEAVE { say "Se ejecuta cada vez que abandona un bloque, incluyendo " ~
             "cuando una excepción ocurre. Se repite en bloques de bucle"}
 
 PRE {
-    say "Impone una precondición a cada entrada de un bloque, " ~ 
+    say "Impone una precondición a cada entrada de un bloque, " ~
         "antes que ENTER (especialmente útil para bucles)";
     say "Si este bloque no returna un valor truthy, " ~
         "una excepción del tipo X::Phaser::PrePost será levantada.";
@@ -1209,7 +1209,7 @@ for 0..2 {
 }
 
 POST {
-    say "Impone una postcondAsserts a poscondición a la salida de un bloque, " ~ 
+    say "Impone una postcondAsserts a poscondición a la salida de un bloque, " ~
         "después de LEAVE (especialmente útil para bucles)";
     say "Si este bloque no returna un valor truthy, " ~
         "una excepción del tipo X::Phaser::PrePost será levantada, como con PRE.";
@@ -1250,14 +1250,14 @@ sub do-db-stuff {
 ## Prefijos de sentencias
 
 ```perl6
-## Los prefijos de sentencias actúan como los phasers: Ellos afectan el 
+## Los prefijos de sentencias actúan como los phasers: Ellos afectan el
 ## comportamiento del siguiente código.
 ## Debido a que son ejecutados en línea con el código ejecutable, ellos
 ## se escriben en letras minúsculas. (`try` and `start` están teoréticamente
 ## en esa lista, pero serán explicados en otra parte)
 ## Nota: Ningunos de estos (excepto `start`) necesitan las llaves `{` y `}`.
 
-## - `do` (el cual ya viste) - ejecuta un bloque o una sentencia como un 
+## - `do` (el cual ya viste) - ejecuta un bloque o una sentencia como un
 ## término.
 ## Normalmente no puedes usar una sentencia como un valor (o término):
 ##
@@ -1289,7 +1289,7 @@ say join ',', gather if False {
 ## - `eager` - Evalúa una sentencia ávidamente (forza contexto ávido)
 ## No intentes esto en casa:
 ##
-##    eager 1..*; # esto probablemente se colgará por un momento 
+##    eager 1..*; # esto probablemente se colgará por un momento
 ##                # (y podría fallar...).
 ##
 ## Pero considera lo siguiente:
@@ -1302,13 +1302,13 @@ constant tres-veces = eager gather for ^3 { say take $_ }; #=> 0 1 2
 ## Iterables
 
 ```perl6
-## En Perl 6, los iterables son objetos que pueden ser iterados similar 
-## a la construcción `for`. 
+## En Raku, los iterables son objetos que pueden ser iterados similar
+## a la construcción `for`.
 ## `flat`, aplana iterables:
 say (1, 10, (20, 10) ); #=> (1 10 (20 10)) Nota como la agrupación se mantiene
 say (1, 10, (20, 10) ).flat; #=> (1 10 20 10) Ahora el iterable es plano
 
-## - `lazy` - Aplaza la evaluación actual hasta que el valor sea requirido 
+## - `lazy` - Aplaza la evaluación actual hasta que el valor sea requirido
 ## (forza contexto perezoso)
 my @lazy-array = (1..100).lazy;
 say @lazy-array.is-lazy; #=> True # Chequea por "pereza" con el método `is-lazy`.
@@ -1333,7 +1333,7 @@ quietly { warn 'Esto es una advertencia!' }; #=> No salida
 ## ¡Todo el mundo ama los operadores! Tengamos más de ellos.
 
 ## La lista de precedencia puede ser encontrada aquí:
-## https://docs.perl6.org/language/operators#Operator_Precedence
+## https://docs.raku.org/language/operators#Operator_Precedence
 ## Pero primero, necesitamos un poco de explicación acerca
 ## de la asociatividad:
 
@@ -1356,7 +1356,7 @@ $a ! $b ! $c; # con asociatividad de lista `!`, esto es `infix:<>`
 ## Okay, has leído todo esto y me imagino que debería mostrarte
 ## algo interesante.
 ## Te mostraré un pequeño secreto (o algo no tan secreto):
-## En Perl 6, todos los operadores son actualmente solo subrutinas.
+## En Raku, todos los operadores son actualmente solo subrutinas.
 
 ## Puedes declarar un operador como declaras una subrutina:
 sub prefix:<ganar>($ganador) { # se refiere a las categorías de los operadores
@@ -1374,14 +1374,14 @@ sub postfix:<!>(Int $n) {
 }
 say 5!; #=> 120
         # Operadores sufijos (postfix) van *directamente* después del témino.
-        # No espacios en blanco. Puedes usar paréntesis para disambiguar, 
+        # No espacios en blanco. Puedes usar paréntesis para disambiguar,
         # i.e. `(5!)!`
 
 
 sub infix:<veces>(Int $n, Block $r) { # infijo va en el medio
   for ^$n {
     $r(); # Necesitas los paréntesis explícitos para invocar la función
-		  # almacenada en la variable `$r`. De lo contrario, te estaría 
+		  # almacenada en la variable `$r`. De lo contrario, te estaría
 		  # refiriendo a la variable (no a la función), como con `&r`.
   }
 }
@@ -1399,33 +1399,33 @@ say [5]; #=> 3125
          # un circunfijo va alrededor. De nuevo, no espacios en blanco.
 
 sub postcircumfix:<{ }>(Str $s, Int $idx) {
-  ## un pos-circunfijo es 
+  ## un pos-circunfijo es
   ## "después de un término y alrededor de algo"
   $s.substr($idx, 1);
 }
 say "abc"{1}; #=> b
               # depués del término `"abc"`, y alrededor del índice (1)
 
-## Esto es de gran valor -- porque todo en Perl 6 usa esto.
+## Esto es de gran valor -- porque todo en Raku usa esto.
 ## Por ejemplo, para eliminar una llave de un hash, tu usas el adverbio
 ## `:delete` (un simple argumento con nombre debajo):
 %h{$llave}:delete;
 ## es equivalente a:
-postcircumfix:<{ }>(%h, $llave, :delete); # (puedes invocar 
+postcircumfix:<{ }>(%h, $llave, :delete); # (puedes invocar
 										  # operadores de esta forma)
-## ¡*Todos* usan los mismos bloques básicos! 
+## ¡*Todos* usan los mismos bloques básicos!
 ## Categorías sintácticas (prefix, infix, ...), argumentos nombrados
 ## (adverbios), ... - usados para construir el lenguaje - están al alcance
 ## de tus manos y disponibles para ti.
-## (obviamente, no se te recomienda que hagas un operador de *cualquier 
+## (obviamente, no se te recomienda que hagas un operador de *cualquier
 ## cosa* -- Un gran poder conlleva una gran responsabilidad.)
 ```
 
 ### Meta-operadores!
 
 ```perl6
-## ¡Prepárate! Prepárate porque nos estamos metiendo bien hondo 
-## en el agujero del conejo, y probablemente no querrás regresar a 
+## ¡Prepárate! Prepárate porque nos estamos metiendo bien hondo
+## en el agujero del conejo, y probablemente no querrás regresar a
 ## otros lenguajes después de leer esto.
 ## (Me imagino que ya no quieres a este punto).
 ## Meta-operadores, como su nombre lo sugiere, son operadores *compuestos*.
@@ -1434,14 +1434,14 @@ postcircumfix:<{ }>(%h, $llave, :delete); # (puedes invocar
 ## * El meta-operador reduce (reducir)
 ## Es un meta-operador prefijo que toman una función binaria y
 ## una o varias listas. Sino se pasa ningún argumento,
-## returna un "valor por defecto" para este operador 
+## returna un "valor por defecto" para este operador
 ## (un valor sin significado) o `Any` si no hay ningún valor.
 ##
-## De lo contrario, remueve un elemento de la(s) lista(s) uno a uno, y 
+## De lo contrario, remueve un elemento de la(s) lista(s) uno a uno, y
 ## aplica la función binaria al último resultado (o al primer elemento de
 ## la lista y el elemento que ha sido removido).
 ##
-## Para sumar una lista, podrías usar el meta-operador "reduce" con `+`, 
+## Para sumar una lista, podrías usar el meta-operador "reduce" con `+`,
 ## i.e.:
 say [+] 1, 2, 3; #=> 6
 ## es equivalente a `(1+2)+3`
@@ -1461,20 +1461,20 @@ say [+] (); #=> 0
             # valores sin significado, dado que N*1=N y N+0=N.
 say [//];   #=> (Any)
             # No hay valor por defecto para `//`.
-## También puedes invocarlo con una función de tu creación usando 
+## También puedes invocarlo con una función de tu creación usando
 ## los dobles corchetes:
 sub add($a, $b) { $a + $b }
 say [[&add]] 1, 2, 3; #=> 6
 
 ## * El meta-operador zip
-## Este es un meta-operador infijo que también puede ser usado como un 
+## Este es un meta-operador infijo que también puede ser usado como un
 ## operador "normal". Toma una función binaria opcional (por defecto, solo
-## crear un par), y remueve un valor de cada array e invoca su función 
+## crear un par), y remueve un valor de cada array e invoca su función
 ## binaria hasta que no tenga más elementos disponibles. Al final, returna
 ## un array con todos estos nuevos elementos.
-(1, 2) Z (3, 4); # ((1, 3), (2, 4)), dado que por defecto, la función 
+(1, 2) Z (3, 4); # ((1, 3), (2, 4)), dado que por defecto, la función
                  # crea un array.
-1..3 Z+ 4..6; # (5, 7, 9), usando la función personalizada infix:<+> 
+1..3 Z+ 4..6; # (5, 7, 9), usando la función personalizada infix:<+>
 
 ## Dado que `Z` tiene asociatividad de lista (ve la lista más arriba),
 ## puedes usarlo en más de una lista
@@ -1487,13 +1487,13 @@ say [[&add]] 1, 2, 3; #=> 6
 ## Y para terminar la lista de operadores:
 
 ## * El operador secuencia
-## El operador secuencia es uno de la más poderosas características de 
-## Perl 6: Está compuesto, en la izquierda, de la lista que quieres que
-## Perl 6 use para deducir (y podría incluir una clausura), y en la derecha,
-## un valor o el predicado que dice cuando parar (o Whatever para una 
+## El operador secuencia es uno de la más poderosas características de
+## Raku: Está compuesto, en la izquierda, de la lista que quieres que
+## Raku use para deducir (y podría incluir una clausura), y en la derecha,
+## un valor o el predicado que dice cuando parar (o Whatever para una
 ## lista infinita perezosa).
 my @list = 1, 2, 3 ... 10; # deducción básica
-#my @list = 1, 3, 6 ... 10; # esto muere porque Perl 6 no puede deducir el final
+#my @list = 1, 3, 6 ... 10; # esto muere porque Raku no puede deducir el final
 my @list = 1, 2, 3 ...^ 10; # como con rangos, puedes excluir el último elemento
                             # (la iteración cuando el predicado iguala).
 my @list = 1, 3, 9 ... * > 30; # puedes usar un predicado
@@ -1505,8 +1505,8 @@ my @fib = 1, 1, *+* ... *; # lista infinita perezosa de la serie fibonacci,
 my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalene a lo de arriba)
 my @fib = 1, 1, { $^a + $^b } ... *; #(... también equivalene a lo de arriba)
 ## $a and $b siempre tomarán el valor anterior, queriendo decir que
-## ellos comenzarán con $a = 1 y $b = 1 (valores que hemos asignado 
-## de antemano). Por lo tanto, $a = 1 y $b = 2 (resultado del anterior $a+$b), 
+## ellos comenzarán con $a = 1 y $b = 1 (valores que hemos asignado
+## de antemano). Por lo tanto, $a = 1 y $b = 2 (resultado del anterior $a+$b),
 ## etc.
 
 say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
@@ -1519,29 +1519,29 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
 ## Expresiones Regulares
 
 ```perl6
-## Estoy seguro que has estado esperando por esta parte. Bien, ahora que 
-## sabes algo acerca de Perl 6, podemos comenzar. Primeramente, tendrás 
-## que olvidarte acerca de "PCRE regexps" (perl-compatible regexps) 
+## Estoy seguro que has estado esperando por esta parte. Bien, ahora que
+## sabes algo acerca de Raku, podemos comenzar. Primeramente, tendrás
+## que olvidarte acerca de "PCRE regexps" (perl-compatible regexps)
 ## (expresiones regulares compatible de perl).
 ##
 ## IMPORTANTE: No salte esto porque ya sabes acerca de PCRE. Son totalmente
-## distintos. Algunas cosas son las mismas (como `?`, `+`, y `*`) pero 
+## distintos. Algunas cosas son las mismas (como `?`, `+`, y `*`) pero
 ## algunas veces la semántica cambia (`|`). Asegúrate de leer esto
 ## cuidadosamente porque podrías trospezarte sino lo haces.
 ##
-## Perl 6 tiene muchas características relacionadas con RegExps. Después de
+## Raku tiene muchas características relacionadas con RegExps. Después de
 ## todo, Rakudo se parsea a si mismo. Primero vamos a estudiar la sintaxis
 ## por si misma, después hablaremos acerca de gramáticas (parecido a PEG),
-## las diferencias entre los declaradores `token`, `regex`, y `rule` y 
+## las diferencias entre los declaradores `token`, `regex`, y `rule` y
 ## mucho más.
-## Nota aparte: Todavía tienes acceso a los regexes PCRE usando el 
+## Nota aparte: Todavía tienes acceso a los regexes PCRE usando el
 ## mofificador `:P5` (Sin embargo, no lo discutiremos en este tutorial).
 ##
-## En esencia, Perl 6 implementa PEG ("Parsing Expression Grammars")
+## En esencia, Raku implementa PEG ("Parsing Expression Grammars")
 ## ("Parseado de Expresiones de Gramáticas") nativamente. El orden jerárquico
-## para los parseos ambiguos es determinado por un examen multi-nivel de 
+## para los parseos ambiguos es determinado por un examen multi-nivel de
 ## desempate:
-##  - La coincidencia de token más larga. `foo\s+` le gana a `foo` 
+##  - La coincidencia de token más larga. `foo\s+` le gana a `foo`
 ## 	  (por 2 o más posiciones)
 ##  - El prefijo literal más largo. `food\w*` le gana a `foo\w*` (por 1)
 ##  - Declaración desde la gramática más derivada a la menos derivada
@@ -1550,48 +1550,48 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
 say so 'a' ~~ /a/; #=> True
 say so 'a' ~~ / a /; #=> True #  ¡Más legible con los espacios!
 
-## Nota al lector (del traductor): 
+## Nota al lector (del traductor):
 ## Como pudiste haber notado, he decidido traducir "match" y sus diferentes
-## formas verbales como "coincidir" y sus diferentes formas. Cuando digo que 
+## formas verbales como "coincidir" y sus diferentes formas. Cuando digo que
 ## un regex (o regexp) coincide con cierto texto, me refiero a que el regex
 ## describe cierto patrón dentro del texto. Por ejemplo, el regex "cencia"
-## coincide con el texto "reminiscencia", lo que significa que dentro del 
+## coincide con el texto "reminiscencia", lo que significa que dentro del
 ## texto aparece ese patrón de caracteres (una `c`, seguida de una `e`,
-## (seguida de una `n`, etc.) 
+## (seguida de una `n`, etc.)
 
-## En todos nuestros ejemplos, vamos a usar el operador de 
-## "coincidencia inteligente" contra una expresión regular ("regexp" or 
+## En todos nuestros ejemplos, vamos a usar el operador de
+## "coincidencia inteligente" contra una expresión regular ("regexp" or
 ## "regex" de aquí en adelante). Estamos convirtiendo el resultado usando `so`,
 ## pero en efecto, está devolviendo un objeto Match. Ellos saben como responder
-## a la indexación de lista, indexación de hash, y devolver la cadena de 
+## a la indexación de lista, indexación de hash, y devolver la cadena de
 ## texto coincidente.
-## Los resultados de la coincidencia están disponible como `$/` (en 
+## Los resultados de la coincidencia están disponible como `$/` (en
 ## ámbito implícito lexical). También puedes usar las variables de captura
 ## las cuales comienzan con 0:
 ##    `$0`, `$1', `$2`...
 ##
-## Nota que `~~` no hace un chequeo de inicio/final (es decir, 
+## Nota que `~~` no hace un chequeo de inicio/final (es decir,
 ## el regexp puede coincider con solo un carácter de la cadena de texto).
 ## Explicaremos luego como hacerlo.
 
-## En Perl 6, puedes tener un carácter alfanumérico como un literal,
+## En Raku, puedes tener un carácter alfanumérico como un literal,
 ## todo lo demás debe escaparse usando una barra invertida o comillas.
-say so 'a|b' ~~ / a '|' b /; # `True`. No sería lo mismo si no se escapara `|` 
+say so 'a|b' ~~ / a '|' b /; # `True`. No sería lo mismo si no se escapara `|`
 say so 'a|b' ~~ / a \| b /;  # `True`. Otra forma de escaparlo
 
-## El espacio en blanco actualmente no se significa nada en un regexp, 
+## El espacio en blanco actualmente no se significa nada en un regexp,
 ## a menos que uses el adverbio `:s` (`:sigspace`, espacio significante).
 say so 'a b c' ~~ / a  b  c /; #=> `False`. Espacio no significa nada aquí.
 say so 'a b c' ~~ /:s a b c /; #=> `True`. Agregamos el modificador `:s` aquí.
-## Si usamos solo un espacio entre cadenas de texto en un regexp, Perl 6
+## Si usamos solo un espacio entre cadenas de texto en un regexp, Raku
 ## nos advertirá:
 say so 'a b c' ~~ / a b c /; #=> 'False' # Espacio no significa nada aquí.
 ## Por favor usa comillas o el modificador :s (:sigspace) para suprimir
-## esta advertencia, omitir el espacio, o cambiar el espaciamiento. Para 
-## arreglar esto y hacer los espacios menos ambiguos, usa por lo menos 
+## esta advertencia, omitir el espacio, o cambiar el espaciamiento. Para
+## arreglar esto y hacer los espacios menos ambiguos, usa por lo menos
 ## dos espacios entre las cadenas de texto o usa el adverbio `:s`.
 
-## Como vimos anteriormente, podemos incorporar `:s` dentro de los 
+## Como vimos anteriormente, podemos incorporar `:s` dentro de los
 ## delimitadores de barras. También podemos ponerlos fuera de ellos si
 ## especificamos `m` for `match` (coincidencia):
 say so 'a b c' ~~ m:s/a  b  c/; #=> `True`
@@ -1603,7 +1603,7 @@ say so 'abc' ~~ m[a  b  c]; #=> `True`
 ## minúsculas y mayúsculas:
 say so 'ABC' ~~ m:i{a  b  c}; #=> `True`
 
-## Sin embargo, es importante para como los modificadores son aplicados 
+## Sin embargo, es importante para como los modificadores son aplicados
 ## (lo cual verás más abajo)...
 
 ## Cuantificando - `?`, `+`, `*` y `**`.
@@ -1612,7 +1612,7 @@ so 'ac' ~~ / a  b  c /; # `False`
 so 'ac' ~~ / a  b?  c /; # `True`, la "b" coincidió (apareció) 0 veces.
 so 'abc' ~~ / a  b?  c /; # `True`, la "b" coincidió 1 vez.
 
-## ... Como debes saber, espacio en blancos son importante porque 
+## ... Como debes saber, espacio en blancos son importante porque
 ## determinan en que parte del regexp es el objetivo del modificador:
 so 'def' ~~ / a  b  c? /; # `False`. Solamente la `c` es opcional
 so 'def' ~~ / a  b?  c /; # `False`. Espacio en blanco no es significante
@@ -1642,7 +1642,7 @@ so 'abbbbbbc' ~~ / a  b**3..*  c /; # `True` (rangos infinitos no son un problem
 
 ## - `<[]>` - Clases de carácteres
 ## Las clases de carácteres son equivalentes a las clases `[]` de PCRE,
-## pero usan una sintaxis de Perl 6:
+## pero usan una sintaxis de Raku:
 say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa'
 
 ## Puedes usar rangos:
@@ -1663,7 +1663,7 @@ so 'foo' ~~ / <-[ f o ]> + /; # False
 ## ... y componerlos:
 so 'foo' ~~ / <[ a..z ] - [ f o ]> + /;   # False (cualquier letra excepto f y o)
 so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /;  # True (no letra excepto f and o)
-so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (el signo + no reemplaza la 
+so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (el signo + no reemplaza la
                                           # parte de la izquierda)
 ```
 
@@ -1671,7 +1671,7 @@ so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (el signo + no reemplaza la
 
 ```perl6
 ## Grupo: Puedes agrupar partes de tu regexp con `[]`.
-## Estos grupos *no son* capturados (como con `(?:)` en PCRE). 
+## Estos grupos *no son* capturados (como con `(?:)` en PCRE).
 so 'abc' ~~ / a [ b ] c /; # `True`. El agrupamiento no hace casi nada
 so 'foo012012bar' ~~ / foo [ '01' <[0..9]> ] + bar /;
 ## La línea anterior returna `True`.
@@ -1680,15 +1680,15 @@ so 'foo012012bar' ~~ / foo [ '01' <[0..9]> ] + bar /;
 ## Pero esto no va demasiado lejos, porque no podemos actualmente obtener
 ## devuelta el patrón que coincidió.
 
-## Captura: Podemos actualmente *capturar* los resultados del regexp, 
+## Captura: Podemos actualmente *capturar* los resultados del regexp,
 ## usando paréntesis.
 so 'fooABCABCbar' ~~ / foo ( 'A' <[A..Z]> 'C' ) + bar /; # `True`. (usando `so`
                                                          #  aquí, `$/` más abajo)
 
-## Ok. Comenzando con las explicaciones de grupos. Como dijimos, 
+## Ok. Comenzando con las explicaciones de grupos. Como dijimos,
 ### nuestra objeto `Match` está disponible en la variable `$/`:
-say $/; # Imprimirá algo extraño (explicaremos luego) o 
-		# "Nil" si nada coincidió 
+say $/; # Imprimirá algo extraño (explicaremos luego) o
+		# "Nil" si nada coincidió
 
 ## Como dijimos anteriormente, un objeto Match tiene indexación de array:
 say $/[0]; #=> ｢ABC｣ ｢ABC｣
@@ -1696,15 +1696,15 @@ say $/[0]; #=> ｢ABC｣ ｢ABC｣
            # Aquí, tenemos un array de ellos.
 say $0; # Lo mismo que lo anterior.
 
-## Nuestra captura es `$0` porque es la primera y única captura en el 
-## regexp. Podrías estarte preguntando porque un array y la respuesta es 
+## Nuestra captura es `$0` porque es la primera y única captura en el
+## regexp. Podrías estarte preguntando porque un array y la respuesta es
 ## simple: Algunas capturas (indezadas usando `$0`, `$/[0]` o una nombrada)
 ## será un array si y solo si puedes tener más de un elemento.
 ## (Así que, con `*`, `+` y `**` (cualquiera los operandos), pero no con `?`).
 ## Usemos algunos ejemplos para ver como funciona:
 
 ## Nota: Pusimos A B C entre comillas para demostrar que el espacio en blanco
-## entre ellos no es significante. Si queremos que el espacio en blanco 
+## entre ellos no es significante. Si queremos que el espacio en blanco
 ## *sea* significante, podemos utilizar el modificador `:sigspace`.
 so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; # `True`
 say $/[0]; #=> ｢ABC｣
@@ -1718,22 +1718,22 @@ say $0.WHAT; #=> (Array)
              # Un cuantificador específico siempre capturará un Array,
              #  puede ser un rango o un valor específico (hasta 1).
 
-## Las capturas son indezadas por anidación. Esto quiere decir que un grupo 
-## dentro de un grup estará anidado dentro de su grupo padre: `$/[0][0]`, 
+## Las capturas son indezadas por anidación. Esto quiere decir que un grupo
+## dentro de un grup estará anidado dentro de su grupo padre: `$/[0][0]`,
 ## para este código:
 'hello-~-world' ~~ / ( 'hello' ( <[ \- \~ ]> + ) ) 'world' /;
 say $/[0].Str; #=> hello~
 say $/[0][0].Str; #=> ~
 
-## Esto se origina de un hecho bien simple: `$/` no contiene cadenas de 
-## texto, números enteros o arrays sino que solo contiene objetos Match. 
-## Estos objetos contienen los métodos `.list`, `.hash` y `.Str`. (Pero 
-## también puedes usar `match<llave>` para accesar un hash y `match[indice]` 
+## Esto se origina de un hecho bien simple: `$/` no contiene cadenas de
+## texto, números enteros o arrays sino que solo contiene objetos Match.
+## Estos objetos contienen los métodos `.list`, `.hash` y `.Str`. (Pero
+## también puedes usar `match<llave>` para accesar un hash y `match[indice]`
 ## para accesar un array.
 say $/[0].list.perl; #=> (Match.new(...),).list
                      # Podemos ver que es una lista de objetos Match.
-                     # Estos contienen un montón de información: dónde la 
-					 # coincidencia comenzó o terminó, el "ast" 
+                     # Estos contienen un montón de información: dónde la
+					 # coincidencia comenzó o terminó, el "ast"
 					 # (chequea las acciones más abajo), etc.
 					 # Verás capturas nombradas más abajo con las gramáticas.
 
@@ -1743,9 +1743,9 @@ so 'abc' ~~ / a [ b | y ] c /; # `True`. o "b" o "y".
 so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviamente suficiente...
 
 ## La diferencia entre este `|` y el otro al que estás acustombrado es LTM.
-## LTM significa "Longest Token Matching", traducido libremente como 
+## LTM significa "Longest Token Matching", traducido libremente como
 ## "Coincidencia de Token Más Larga". Esto significa que el motor ("engine")
-## siempre intentará coindidir tanto como sea posible en la cadena de texto. 
+## siempre intentará coindidir tanto como sea posible en la cadena de texto.
 ## Básicamente, intentará el patrón más largo que concuerde con el regexp.
 'foo' ~~ / fo | foo /; # `foo` porque es más largo.
 ## Para decidir cual parte es la "más larga", primero separa el regex en
@@ -1759,19 +1759,19 @@ so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviamente suficiente...
 ## anteriores, aserciones de código, y otras cosas que tradicionalmente no pueden
 ## ser representadas por regexes normales.
 ##
-## Entonces, todas las alternativas se intentan al mismo tiempo, y la 
+## Entonces, todas las alternativas se intentan al mismo tiempo, y la
 ## más larga gana.
 ## Ejemplos:
 ## DECLARATIVO | PROCEDIMENTAL
 / 'foo' \d+     [ <subrule1> || <subrule2> ] /;
 ## DECLARATIVO (grupos anidados no son un problema)
 / \s* [ \w & b ] [ c | d ] /;
-## Sin embargo, las clausuras y la recursión (de regexes nombrados) 
+## Sin embargo, las clausuras y la recursión (de regexes nombrados)
 ## son procedimentales.
 ## ... Hay más reglas complicadas, como la especifidad (los literales ganan
 ## son las clases de caracteres)
 +
-## Nota: la primera coincidencia `or` todavía existen, pero ahora se 
+## Nota: la primera coincidencia `or` todavía existen, pero ahora se
 ## deletrea `||`
 'foo' ~~ / fo || foo /; # `fo` ahora.
 ```
@@ -1779,19 +1779,19 @@ so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviamente suficiente...
 ## Extra: la subrutina MAIN
 
 ```perl6
-## La subrutina `MAIN` se invoca cuando tu ejecuta un archivo de Perl 6 
-## directamente. Es realmente poderosa porque Perl 6 actualmente parsea 
-## los argumentos y los pasas a la subrutina. También maneja argumentos 
+## La subrutina `MAIN` se invoca cuando tu ejecuta un archivo de Raku
+## directamente. Es realmente poderosa porque Raku actualmente parsea
+## los argumentos y los pasas a la subrutina. También maneja argumentos
 ## nombrados (`--foo`) y hasta autogenerará un `--help`.
 sub MAIN($nombre) { say "¡Hola, $nombre!" }
 ## Esto produce:
-##    $ perl6 cli.pl
+##    $ raku cli.pl
 ##    Uso:
 ##      t.pl <nombre>
 
-## Y dado que una subrutina regular en Perl 6, puedes tener múltiples 
+## Y dado que una subrutina regular en Raku, puedes tener múltiples
 ## despachos:
-## (usando un "Bool" por un argumento nombrado para que podamos hacer 
+## (usando un "Bool" por un argumento nombrado para que podamos hacer
 ## `--replace` a cambio de `--replace=1`)
 subset File of Str where *.IO.d; # convierte a un objeto IO para chequear si
 							     # un archivo existe
@@ -1800,7 +1800,7 @@ multi MAIN('add', $key, $value, Bool :$replace) { ... }
 multi MAIN('remove', $key) { ... }
 multi MAIN('import', File, Str :$as) { ... } # omitiendo parámetros nombrados
 ## Esto produce:
-##    $ perl6 cli.pl
+##    $ raku cli.pl
 ##    Uso:
 ##      t.pl [--replace] add <key> <value>
 ##      t.pl remove <key>
@@ -1814,7 +1814,7 @@ multi MAIN('import', File, Str :$as) { ... } # omitiendo parámetros nombrados
 ### Lista de cosas
 
 ```perl6
-## Consideramos que por ahora ya sabes lo básico de Perl 6.
+## Consideramos que por ahora ya sabes lo básico de Raku.
 ## Esta sección es solo para listar algunas operaciones comunes
 ## las cuales no están en la "parte principal" del tutorial.
 
@@ -1825,13 +1825,13 @@ multi MAIN('import', File, Str :$as) { ... } # omitiendo parámetros nombrados
 ##  (los cuales representan los números -1, 0 o +1).
 1 <=> 4; # comparación de orden para caracteres numéricos
 'a' leg 'b'; # comparación de orden para cadenas de texto
-$obj eqv $obj2; # comparación de orden usando la semántica eqv 
+$obj eqv $obj2; # comparación de orden usando la semántica eqv
 
 ## * Ordenación genérica
 3 before 4; # True
 'b' after 'a'; # True
 
-## * Operador (por defecto) de circuito corto 
+## * Operador (por defecto) de circuito corto
 ## Al igual que `or` y `||`, pero devuelve el primer valor *defined*
 ## (definido):
 say Any // Nil // 0 // 5; #=> 0
@@ -1843,9 +1843,9 @@ say True ^^ False; #=> True
 ## * Flip Flop
 ## Los operadores flip flop (`ff` y `fff`, equivalente a `..`/`...` en P5)
 ## son operadores que toman dos predicados para evalualarlos:
-## Ellos son `False` hasta que su lado izquierdo devuelve `True`, entonces 
+## Ellos son `False` hasta que su lado izquierdo devuelve `True`, entonces
 ## son `True` hasta que su lado derecho devuelve `True`.
-## Como los rangos, tu puedes excluir la iteración cuando se convierte en 
+## Como los rangos, tu puedes excluir la iteración cuando se convierte en
 ## `True`/`False` usando `^` en cualquier lado.
 ## Comencemos con un ejemplo:
 for <well met young hero we shall meet later> {
@@ -1861,25 +1861,25 @@ for <well met young hero we shall meet later> {
 }
 ## Esto imprimirá "young hero we shall meet" (exluyendo "met"):
 ## el flip-flop comenzará devolviendo `True` cuando primero encuentra "met"
-## (pero no returnará `False` por "met" dabido al `^` al frente de `ff`), 
+## (pero no returnará `False` por "met" dabido al `^` al frente de `ff`),
 ## hasta que ve "meet", lo cual es cuando comenzará devolviendo `False`.
 
 ## La diferencia entre `ff` (al estilo de awk) y `fff` (al estilo de sed)
-## es que `ff` probará su lado derecho cuando su lado izquierdo cambia 
+## es que `ff` probará su lado derecho cuando su lado izquierdo cambia
 ## a `True`, y puede returnar a `False` inmediamente (*excepto* que será
-## `True` por la iteración con la cual coincidió). Por lo contrario, 
-## `fff` esperará por la próxima iteración para intentar su lado 
+## `True` por la iteración con la cual coincidió). Por lo contrario,
+## `fff` esperará por la próxima iteración para intentar su lado
 ## derecho, una vez que su lado izquierdo ha cambiado:
 .say if 'B' ff 'B' for <A B C B A>; #=> B B
                                     # porque el lado derecho se puso a prueba
                                     # directamente (y returnó `True`).
                                     # Las "B"s se imprimen dadó que coincidió
-                                    # en ese momento (returnó a `False` 
+                                    # en ese momento (returnó a `False`
                                     # inmediatamente).
 .say if 'B' fff 'B' for <A B C B A>; #=> B C B
                                      # El lado derecho no se puso a prueba
                                      # hasta que `$_` se convirtió en "C"
-                                     # (y por lo tanto no coincidió 
+                                     # (y por lo tanto no coincidió
                                      # inmediamente).
 
 ## Un flip-flop puede cambiar estado cuantas veces se necesite:
@@ -1901,35 +1901,35 @@ for (1, 3, 60, 3, 40, 60) { # Nota: los paréntesis son superfluos aquí
 ## que no pasará la primera vez:
 for <a b c> {
   .say if * ^ff *; # el flip-flop es `True` y nunca returna a `False`,
-                   # pero el `^` lo hace *que no se ejecute* en la 
+                   # pero el `^` lo hace *que no se ejecute* en la
                    # primera iteración
                    #=> b c
 }
 
-## - `===` es la identidad de valor y usa `.WHICH` 
+## - `===` es la identidad de valor y usa `.WHICH`
 ## en los objetos para compararlos.
-## - `=:=` es la identidad de contenedor y usa `VAR()` 
+## - `=:=` es la identidad de contenedor y usa `VAR()`
 ## en los objetos para compararlos.
 
 ```
 Si quieres ir más allá de lo que se muestra aquí, puedes:
 
- - Leer la [documentación de Perl 6](https://docs.perl6.org/). Esto es un recurso
- grandioso acerca de Perl 6. Si estás buscando por algo en particular, usa la
+ - Leer la [documentación de Raku](https://docs.raku.org/). Esto es un recurso
+ grandioso acerca de Raku. Si estás buscando por algo en particular, usa la
  barra de búsquedas. Esto te dará un menú de todas las páginas concernientes
  a tu término de búsqueda (¡Es mucho mejor que usar Google para encontrar
- documentos acerca de Perl 6!)
- - Leer el [Perl 6 Advent Calendar](http://perl6advent.wordpress.com/). Este es 
- un gran recurso de fragmentos de código de Perl 6 y explicaciones. Si la documentación
+ documentos acerca de Raku!)
+ - Leer el [Raku Advent Calendar](https://rakuadventcalendar.wordpress.com/). Este es
+ un gran recurso de fragmentos de código de Raku y explicaciones. Si la documentación
  no describe algo lo suficientemente bien, puedes encontrar información más detallada
  aquí. Esta información puede ser un poquito más antigua pero hay muchos ejemplos y
- explicaciones. Las publicaciones fueron suspendidas al final del 2015 cuando 
- el lenguaje fue declarado estable y Perl 6.c fue lanzado.
- - Unirte a `#perl6` en `irc.freenode.net`. Las personas aquí son siempre serviciales.
- - Chequear la [fuente de las funciones y clases de Perl 6
- ](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo está principalmente 
- escrito en Perl 6 (con mucho de NQP, "Not Quite Perl" ("No Perl Todavía"), un
- subconjunto de Perl 6 que es más fácil de implementar y optimizar).
- - Leer [documentos acerca del diseño del lenguaje](http://design.perl6.org).
+ explicaciones. Las publicaciones fueron suspendidas al final del 2015 cuando
+ el lenguaje fue declarado estable y Raku.c fue lanzado.
+ - Unirte a `#raku` en `irc.freenode.net`. Las personas aquí son siempre serviciales.
+ - Chequear la [fuente de las funciones y clases de Raku
+ ](https://github.com/rakudo/rakudo/tree/master/src/core.c). Rakudo está principalmente
+ escrito en Raku (con mucho de NQP, "Not Quite Perl" ("No Perl Todavía"), un
+ subconjunto de Raku que es más fácil de implementar y optimizar).
+ - Leer [documentos acerca del diseño del lenguaje](http://design.raku.org).
  Estos explican P6 desde la perspectiva de un implementador, lo cual es bastante
  interesante.