Merge branch 'master' into master

1 files changed, 1935 insertions, 0 deletions

diff --git a/es-es/perl6-es.html.markdown b/es-es/perl6-es.html.markdown
new file mode 100644
index 00000000..bf3ae65e
--- /dev/null
+++ b/es-es/perl6-es.html.markdown
@@ -0,0 +1,1935 @@
+---
+name: perl6
+category: language
+language: perl6
+filename: perl6-es.p6
+contributors:
+    - ["vendethiel", "http://github.com/vendethiel"]
+    - ["Samantha McVey", "https://cry.nu"]
+translators:
+    - ["Luis F. Uceta", "https://github.com/uzluisf"]
+lang: es-es
+---
+
+Perl 6 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 
+se ejecuta en JVM y en [MoarVM](http://moarvm.com).
+
+Meta-nota: dos signos de números (##) son usados para indicar párrafos,
+mientras que un solo signo de número (#) indica notas.
+
+`#=>` representa la salida de un comando.
+
+```perl6
+# Un comentario de una sola línea comienza con un signo de número
+
+#`(
+  Comentarios multilíneas usan #` y signos de encerradura tales 
+  como (), [], {}, 「」, etc.
+)
+```
+
+## Variables
+
+```perl6
+## En Perl 6, se declara una variable lexical usando `my`
+my $variable;
+## Perl 6 tiene 3 tipos básicos de variables: escalares, arrays, y hashes.
+```
+
+### Escalares
+
+```perl6
+# Un escalar representa un solo valor. Variables escalares comienzan 
+# con un `$`
+
+my $str = 'Cadena';
+# 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 
+## (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 $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
+```
+
+### Arrays y Listas
+
+```perl6
+## Un array representa varios valores. Variables arrays comienzan con `@`.
+## Las listas son similares pero son un tipo inmutable.
+
+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.
+my @array = 1, 2, 3;
+
+say @array[2]; # Los índices de un array empiezan por el 0 -- Este es
+			   # el tercer elemento.
+
+say "Interpola todos los elementos de un array usando [] : @array[]";
+#=> Interpola todos los elementos de un array usando [] : 1 2 3
+
+@array[0] = -1;      # Asigna un nuevo valor a un índice del array
+@array[0, 1] = 5, 6; # Asigna varios valores
+
+my @llaves = 0, 2;
+@array[@llaves] = @letras; # Asignación usando un array que contiene valores 
+						   # índices
+say @array; #=> a 6 b
+```
+
+### Hashes, o Pairs (pares) de llaves-valores.
+
+```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 
+## 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 
+                                     # 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
+## con un número par de elementos fácilmente.
+my %hash = <llave1 valor1 llave2 valor2>;
+
+my %hash = llave1 => 'valor1', llave2 => 'valor2'; # ¡el mismo resultado!
+
+## También puedes usar la sintaxis "pareja con dos puntos":
+## (especialmente útil para parámetros nombrados que verás más adelante)
+my %hash = :w(1),    # equivalente a `w => 1`
+                     # esto es útil para el atajo `True`:
+           :truey,   # equivalente a `:truey(True)`, o `truey => True`
+                     # y para el `False`:
+           :!falsey, # equivalente a `:falsey(False)`, o `falsey => False`
+           ;
+
+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
+                     # palabras desnudas (barewords en inglés))
+```
+
+## Subrutinas
+
+```perl6
+## Subrutinas, o funciones como otros lenguajes las llaman, son
+## creadas con la palabra clave `sub`.
+sub di-hola { say "¡Hola, mundo!" }
+
+## 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) {
+    say "¡Hola, $nombre!";
+}
+
+## Una subrutina devuelve el último valor evaluado del bloque.
+sub devolver-valor {
+    5;
+}
+say devolver-valor; # imprime 5
+sub devolver-vacio {
+}
+say devolver-vacio; # imprime Nil
+
+## Algunas estructuras de control producen un valor. Por ejemplo if:
+sub devuelva-si {
+	if True {
+		"Truthy";
+	}
+}
+say devuelva-si; # imprime Truthy
+
+## Otras no, como un bucle for:
+sub return-for {
+    for 1, 2, 3 { }
+}
+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 
+		un argumento, o returnaré mi argumento";
+  $arg;
+}
+con-opcional;    # devuelve Any
+con-opcional();  # devuelve Any
+con-opcional(1); # devuelve 1
+
+## También puedes proveer un argumento por defecto para 
+## cuando los argumentos no son proveídos:
+sub hola-a($nombre = "Mundo") {
+  say "¡Hola, $nombre!";
+}
+hola-a; 		#=> ¡Hola, Mundo!
+hola-a(); 		#=> ¡Hola, Mundo!
+hola-a('Tú'); 	#=> ¡Hola, Tú!
+
+## De igual manera, al usar la sintaxis parecida a la de los hashes
+## (¡Hurra, sintaxis unificada!), puedes pasar argumentos *nombrados*
+## a una subrutina. Ellos son opcionales, y por defecto son del tipo "Any".
+sub con-nombre($arg-normal, :$nombrado) {
+  say $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
+## 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: 
+con-nombre(1, 'nombrado' => 6);
+
+con-nombre(2, :nombrado(5)); #=> 7
+
+## Para hacer un argumento nombrado mandatorio, puedes utilizar el
+## inverso de `?`, `!`:
+sub con-nombre-mandatorio(:$str!)  {
+  say "$str!";
+}
+con-nombre-mandatorio(str => "Mi texto"); #=> Mi texto!
+con-nombre-mandatorio;   # error al tiempo de ejecución:
+						 # "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"
+						 # ("Demasiados argumentos posicionales proveídos")
+
+## Si una subrutina toma un argumento booleano nombrado ...
+sub toma-un-bool($nombre, :$bool) {
+  say "$nombre toma $bool";
+}
+## ... puedes usar la misma sintaxis de hash de un "booleano corto":
+takes-a-bool('config', :bool);  # config toma True
+takes-a-bool('config', :!bool); # config toma False
+
+## También puedes proveer tus argumentos nombrados con valores por defecto:
+sub nombrado-definido(:$def = 5) {
+  say $def;
+}
+nombrado-definido; #=> 5
+nombrado-definido(def => 15); #=> 15
+
+## 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;
+my &otra-s = sub { say "¡Función anónima!" }
+
+## Una subrutina puede tener un parámetro "slurpy", o "no importa cuantos",
+## indicando que la función puede recibir cualquier número de parámetros.
+sub muchos($principal, *@resto) {  #`*@` (slurpy) consumirá lo restante
+## Nota: Puedes tener parámetros *antes que* un parámetro "slurpy" (como
+## aquí) pero no *después* de uno.
+  say @resto.join(' / ') ~ "!";
+}
+say muchos('Feliz', 'Cumpleaño', 'Cumpleaño'); #=> Feliz / Cumpleaño!
+                                           # 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" `|`
+## (actualmente no es el único rol de este operador pero es uno de ellos)
+sub concat3($a, $b, $c) {
+  say "$a, $b, $c";
+}
+concat3(|@array); #=> a, b, c
+                  # `@array` fue "aplanado" como parte de la lista de argumento
+```
+
+## Contenedores
+
+```perl6
+## En Perl 6, 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 
+## mutable usando `is rw`:
+sub mutar($n is rw) {
+  $n++;
+  say "¡\$n es ahora $n!";
+}
+
+my $m = 42;
+mutar $m; # ¡$n es ahora 43!
+
+## Esto funciona porque estamos pasando el contenedor $m para mutarlo. Si
+## intentamos pasar un número en vez de pasar una variable, no funcionará
+## dado que no contenedor ha sido pasado y números enteros son inmutables
+## por naturaleza:
+
+mutar 42; # Parámetro '$n' esperaba un contenedor mutable, 
+		  # pero recibió un valor Int
+
+## Si en cambio quieres una copia, debes usar `is copy`.
+
+## Por si misma, una subrutina devuelve un contenedor, lo que significa
+## que puede ser marcada con rw:
+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
+				# `x-almacena` es un identificador).
+say $x; #=> 52
+```
+
+## Estructuras de control
+### Condicionales
+
+```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 
+## por supuesto False. Todos los valores son Truthy.
+if True {
+  say "¡Es verdadero!";
+}
+
+unless False {
+  say "¡No es falso!";
+}
+
+## Como puedes observar, no necesitas paréntesis alrededor de condiciones.
+## Sin embargo, necesitas las llaves `{}` alrededor del cuerpo de un bloque:
+# if (true) say; # !Esto no funciona!
+
+## 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 
+##   $valor-si-falsa si es falsa.
+##   my $resultado = $valor condición ?? $valor-si-verdadera !! $valor-si-falsa;
+
+my $edad = 30;
+say $edad > 18 ?? "Eres un adulto" !! "Eres menor de 18";
+```
+
+### given/when, ó switch
+
+```perl6
+## - `given`-`when` se parece al `switch` de otros lenguajes, pero es más
+## poderoso gracias a la coincidencia inteligente ("smart matching" en inglés)
+## y la "variable tópica" $_ de Perl.
+##
+## Esta variable ($_) contiene los argumentos por defecto de un bloque,
+## la iteración actual de un loop (a menos que sea explícitamente
+## nombrado), etc.
+##
+## `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,
+## 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 
+## lugar donde exista una variable `$_`.
+
+given "foo bar" {
+  say $_; #=> foo bar
+  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`) 
+                       # por lo tanto puedes también poner condiciones "normales".
+                       # Este `when` es equivalente a este `if`:
+                       #  if $_ ~~ ($_.chars > 50) {...}
+                       # que significa:
+                       #  if $_.chars > 50 {...}
+    say "¡Una cadena de texto bien larga!";
+  }
+  default { # lo mismo que `when *` (usando la Whatever Star)
+    say "Algo más";
+  }
+}
+```
+
+### Construcciones de bucle
+
+```perl6
+## - `loop` es un bucle infinito si no le pasas sus argumentos,
+## 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` 
+        # en otros lenguajes.
+}
+
+loop (my $i = 0; $i < 5; $i++) {
+  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.
+  say "¡Este es un bucle al estilo de C!";
+}
+
+## - `for` - Hace iteraciones en un array
+for @array -> $variable {
+  say "¡He conseguido una $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 
+## 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. 
+  $_.say; # lo mismo de arriba, lo cual es equivalente.
+}
+
+for @array {
+  # Puedes...
+  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 
+				   # misma variable tópica (`$_`)
+  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.
+if computación-larga() -> $resultado {
+  say "El resultado es $resultado";
+}
+```
+
+## Operadores
+
+```perl6
+## Dados que los lenguajes de la familia Perl son lenguages basados
+## mayormente en operadores, los operadores de Perl 6 son actualmente 
+## subrutinas un poco cómicas en las categorías sintácticas. Por ejemplo,
+## infix:<+> (adición) o prefix:<!> (bool not).
+
+## Las categorías son:
+## - "prefix"  (prefijo): anterior a (como `!` en `!True`).
+## - "postfix" (sufijo):  posterior a (como `++` en `$a++`).
+## - "infix"   (infijo):  en medio de (como `*` en `4 * 3`).
+## - "circumfix" (circunfijo): alrededor de (como `[`-`]` en `[1, 2]`).
+## - "post-circumfix" (pos-circunfijo): alrededor de un término,
+##                     				   posterior a otro término.
+##                     (como `{`-`}` en `%hash{'key'}`)
+
+## La lista de asociatividad y precedencia se explica más abajo.
+
+## ¡Bueno, ya estás listo(a)!
+
+## * Chequeando igualdad
+
+## - `==` se usa en comparaciones numéricas.
+3 == 4; # Falso
+3 != 4; # Verdadero
+
+## - `eq` se usa en comparaciones de cadenas de texto.
+'a' eq 'b';
+'a' ne 'b';  # no igual
+'a' !eq 'b'; # lo mismo que lo anterior
+
+## - `eqv` es equivalencia canónica (or "igualdad profunda")
+(1, 2) eqv (1, 3);
+
+## - Operador de coincidencia inteligente (smart matching): `~~`
+## 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:
+
+## Igualdad de cadena de texto o numérica
+
+'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 
+## como True si el regex coincide con el patrón.
+
+my $obj = 'abc' ~~ /a/;
+say $obj; # ｢a｣
+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 
+## superclases y roles)
+
+1 ~~ Int; # True (1 es un número entero)
+
+## Coincidencia inteligente contra un booleano siempre devuelve ese 
+## booleano (y lanzará una advertencia).
+
+1 ~~ True; # True
+False ~~ True; # True
+
+## La sintaxis general es $arg ~~ &función-returnando-bool;
+## Para una lista completa de combinaciones, usa esta tabla:
+## http://perlcabal.org/syn/S03.html#Smart_matching
+
+## También, por supuesto, tienes `<`, `<=`, `>`, `>=`.
+## Sus equivalentes para cadenas de texto están disponibles:
+## `lt`, `le`, `gt`, `ge`.
+3 > 4;
+
+## * Constructores de rango
+3 .. 7; # 3 a 7, ambos incluidos
+## `^` en cualquier lado excluye a ese lado:
+3 ^..^ 7; # 3 a 7, no incluidos (básicamente `4 .. 6`)
+## 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 
+## 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
+## 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.
+
+## Un índice de array también puede ser una clausura ("closure" en inglés).
+## Será llamada con la longitud como el argumento
+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, 
+##		  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 
+## 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,
+                             # solo los 15 números necesarios será calculados.
+say @números; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87
+              # (solamente 20 valores)
+
+## * And &&, Or ||
+3 && 4; # 4, el cual es Truthy. Invoca `.Bool` en `4` y obtiene `True`.
+0 || False; # False. Invoca `.Bool` en `0`
+
+## * Versiones circuito corto de lo de arriba
+## && Devuelve el primer argumento que evalúa a False, o el último.
+
+my ( $a, $b, $c ) = 1, 0, 2;
+$a && $b && $c; # Devuelve 0, el primer valor que es False
+
+## || Devuelve el primer argumento que evalúa a True.
+$b || $a; # 1
+
+## Y porque tu lo querrás, también tienes operadores de asignación
+## 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.
+```
+
+## ¡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 
+## lenguaje :-).
+```
+
+### !Desempacado!
+
+```perl6
+## Es la abilidad de extraer arrays y llaves (También conocido como
+## "destructuring"). También funcionará en `my` y en las listas de parámetros.
+my ($f, $g) = 1, 2;
+say $f; #=> 1
+my ($, $, $h) = 1, 2, 3; # mantiene los anónimos no interesante
+say $h; #=> 3
+
+my ($cabeza, *@cola) = 1, 2, 3; # Sí, es lo mismo que con subrutinas "slurpy"
+my (*@small) = 1;
+
+sub desempacar_array(@array [$fst, $snd]) {
+  say "Mi primero es $fst, mi segundo es $snd! De todo en todo, soy un @array[].";
+  # (^ recuerda que `[]` interpola el array)
+}
+desempacar_array(@cola); #=> My first is 2, my second is 3 ! All in all, I'm 2 3
+
+
+## Si no está usando el array, puedes también mantenerlo anónimo, como un
+## escalar:
+sub primero-de-array(@ [$fst]) { $fst }
+primero-de-array(@small); #=> 1
+primero-de-array(@tail); # Lanza un error "Demasiados argumentos posicionales
+                         # proveídos"
+                         # (lo que significa que el array es muy grande).
+
+## También puedes usar un slurp ...
+sub slurp-en-array(@ [$fst, *@rest]) { # Podrías mantener `*@rest` anónimos
+  say $fst + @rest.elems; # `.elems` returna la longitud de una lista.
+                          # Aquí, `@rest`  es `(3,)`, since `$fst` holds the `2`.
+}
+slurp-en-array(@tail); #=> 3
+
+## Hasta podrías hacer un extracción usando una slurpy (pero no sería útil ;-).)
+sub fst(*@ [$fst]) { # o simplemente: `sub fst($fst) { ... }`
+  say $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 
+## `%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 
+## 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)
+
+## La última expresión de una subrutina es devuelta inmediatamente
+## (aunque puedes usar la palabra clave `return`):
+sub siguiente-indice($n) {
+  $n + 1;
+}
+my $nuevo-n= siguiente-indice(3); # $nuevo-n es ahora 4
+
+## 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) 
+sub lista-de($n) {
+  do for ^$n { # nota el uso del operador de rango `^` (`0..^N`)
+    $_        # iteración de bucle actual
+  }
+}
+my @list3 = lista-de(3); #=> (0, 1, 2)
+```
+
+### lambdas
+
+```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 
+## 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" 
+## (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` 
+  # Una vez que la condición evalúa a True, el bucle terminará
+  map({ return True if $_ == $elem }, @array);
+}
+sub truthy-array(@array) {
+  # esto producirá un array de `True` Y `False`:
+  # (también puedes decir `anon sub` para "subrutina anónima")
+  map(sub ($i) { if $i { return True } else { return False } }, @array);
+  # ^ el `return` solo devuelve desde la `sub`
+}
+
+## También puedes usar la "whatever star" para crear una función anónima
+## (terminará con el último operador en la expresión actual)
+my @arraymas3 = map(*+3, @array); # `*+3` es lo mismo que `{ $_ + 3 }`
+my @arraymas3 = map(*+*+3, @array); # lo mismo que `-> $a, $b { $a + $b + 3 }`
+                                     # también `sub ($a, $b) { $a + $b + 3 }`
+say (*/2)(4); #=> 2
+                  # Inmediatamente ejecuta la función que Whatever creó.
+say ((*+3)/5)(5); #=> 1.6
+                  # ¡funciona hasta con los paréntesis!
+
+## Pero si necesitas más que un argumento (`$_`) en un bloque
+## (sin depender en `-> {}`), también puedes usar la sintaxis implícita
+## de argumento, `$` :
+map({ $^a + $^b + 3 }, @array); # equivalente a lo siguiente:
+map(sub ($a, $b) { $a + $b + 3 }, @array); # (aquí con `sub`)
+
+## Nota : Esos son ordernados lexicográficamente.
+# `{ $^b / $^a }` es como `-> $a, $b { $b / $a }`
+```
+
+### Acerca de tipos...
+
+```perl6
+## Perl 6 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.
+## Las construcciones para declarar tipos son "class", "role", lo cual
+## verás más adelante.
+
+## Por ahora, examinemos "subset" (subconjunto).
+## Un "subset" es un "sub-tipo" con chequeos adicionales.
+## Por ejemplo: "un número entero bien grande es un Int que es mayor que 500"
+## Puedes especificar el tipo del que creas el subconjunto (por defecto, Any),
+## y añadir chequeos adicionales con la palabra clave "where" (donde):
+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 
+## tipo de los argumento, o precondiciones arbitrarias, como con un tipo o
+## un `where`:
+
+## con tipos
+multi sub dilo(Int $n) { # nota la palabra clave `multi` aquí
+  say "Número: $n";
+}
+multi dilo(Str $s) { # un multi es una subrutina por defecto
+  say "Cadena de texto: $s";
+}
+dilo("azul"); # prints "Cadena de texto: azul"
+dilo(True); # falla al *tiempo de compilación* con
+            # "calling 'dilo' will never work with arguments of types ..."
+			# (invocar 'dilo' nunca funcionará con argumentos de tipos ...")
+## con precondición arbitraria (¿recuerdas los subconjuntos?):
+multi es-grande(Int $n where * > 50) { "¡Sí!" } # usando una clausura
+multi es-grande(Int $ where 10..50) { "Tal vez." } # Usando coincidencia inteligente
+                                              # (podrías usar un regexp, etc)
+multi es-grande(Int $) { "No" }
+
+subset Par of Int where * %% 2;
+
+multi inpar-o-par(Par) { "Par" } # El caso principal usando el tipo.
+                                   # No nombramos los argumentos,
+multi inpar-o-par($) { "Inpar" } # "else"
+
+## ¡Podrías despachar basado en la presencia de argumentos posicionales!
+multi sin_ti-o-contigo(:$with!) { # Necesitas hacerlo mandatorio
+                                  # para despachar en contra del argumento.
+  say "¡Puedo vivir! Actualmente, no puedo.";
+}
+multi sin_ti-o-contigo {
+  say "Definitivamente no puedo vivir.";
+}
+## 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. 
+##
+## - `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!) {}
+##
+## (¡lo pusimos en un comentario dado que ejecutando esto sería una terrible
+## idea!)
+```
+
+## Ámbito (Scoping)
+
+```perl6
+## En Perl 6, 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.
+## Esto se llama "ámbito léxico", donde en los bloques internos,
+## puedes acceder variables de los bloques externos.
+my $archivo-en-ámbito = 'Foo';
+sub externo {
+  my $ámbito-externo = 'Bar';
+  sub interno {
+    say "$archivo-en-ámbito $ámbito-externo";
+  }
+  &interno; # devuelve la función
+}
+outer()(); #=> 'Foo Bar'
+
+## 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).
+```
+
+## Twigils
+
+```perl6
+## Hay muchos `twigils` especiales (sigilos compuestos) en Perl 6. 
+## 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:
+## ! Atributo (miembro de la clase)
+## . Método (no una variable realmente)
+
+## El twigil `*`: Ámbito dinámico
+## Estas variables usan el twigil `*` para marcar variables con ámbito
+## dinámico. Variables con ámbito dinámico son buscadas a través del
+## invocador, no a través del ámbito externo.
+
+my $*ambito_din_1 = 1;
+my $*ambito_din_2 = 10;
+
+sub di_ambito {
+  say "$*ambito_din_1 $*ambito_din_2";
+}
+
+sub invoca_a_di_ambito {
+  my $*ambito_din_1 = 25; # Define a $*ambito_din_1 solo en esta subrutina.
+  $*ambito_din_2 = 100; # Cambiará el valor de la variable en ámbito.
+  di_ambito(); #=> 25 100 $*ambito_din_1 y 2 serán buscadas en la invocación.
+             # Se usa el valor de $*ambito_din_1 desde el ámbito léxico de esta
+             # subrutina aunque los bloques no están anidados (están anidados por
+             # invocación).
+}
+di_ambito(); #=> 1 10
+invoca_a_di_ambito(); #=> 25 100
+                # Se usa a $*ambito_din_1 como fue definida en invoca_a_di_ambito
+                # aunque la estamos invocando desde afuera.
+di_ambito(); #=> 1 100 Cambiamos el valor de $*ambito_din_2 en invoca_a_di_ambito
+             #         por lo tanto su valor a cambiado.
+```
+
+## Modelo de Objeto
+
+```perl6
+## Para invocar a un método en un objeto, agrega un punto seguido por el
+## 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 
+## mutables con `is rw`).
+## 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
+## 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).
+
+class Clase-Atrib {
+  has $.atrib; # `$.atrib` es inmutable.
+               # Desde dentro de la clase, usa `$!atrib` para modificarlo.
+  has $.otro-atrib is rw; # Puedes marcar un atributo como público con `rw`.
+  has Int $!atrib-privado = 10;
+
+  method devolver-valor {
+    $.atrib + $!atrib-privado;
+  }
+
+  method asignar-valor($param) { # Métodos pueden tomar parámetros.
+    $!attrib = $param;   # Esto funciona porque `$!` es siempre mutable.
+	# $.attrib = $param; # Incorrecto: No puedes usar la versión inmutable `$.`.
+
+    $.otro-atrib = 5; # Esto funciona porque `$.otro-atrib` es `rw`.
+  }
+
+  method !metodo-privado {
+    say "Este método es privado para la clase !";
+  }
+};
+
+## 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 
+## esto adelante).
+my $class-obj = Clase-Atrib.new(atrib => 5);
+say $class-obj.devolver-valor; #=> 5
+# $class-obj.atrib = 5; # Esto falla porque `has $.atrib` es inmutable
+$class-obj.otro-atrib = 10; # En cambio, esto funciona porque el atributo
+							# público es mutable (`rw`).
+```
+
+### Herencia de Objeto
+
+```perl6
+## Perl 6 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. 
+
+class Padre {
+  has $.edad;
+  has $.nombre;
+  # Este submétodo no será heredado por la clase Niño.
+  submethod color-favorito {
+    say "Mi color favorito es Azul";
+  }
+  # Este método será heredado
+  method hablar { say "Hola, mi nombre es $!nombre" }
+}
+# 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 niño no ha aprendido a hablar todavía.
+}
+my Padre $Richard .= new(edad => 40, nombre => 'Richard');
+$Richard.color-favorito; #=> "Mi color favorito es Azul"
+$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 
+				 # 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: 
+## `$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 
+## `val => 5`.
+```
+
+### Roles, o Mixins
+
+```perl6
+## Roles son suportados también (comúnmente llamados Mixins en otros
+## lenguajes)
+role PrintableVal {
+  has $!counter = 0;
+  method print {
+    say $.val;
+  }
+}
+
+## Se "importa" un mixin (un "role") con "does":
+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 
+  ## puede acceder los métodos y atributos privados de su rol (pero no lo inverso!):
+  method access {
+    say $!counter++;
+  }
+
+  ## Sin embargo, esto:
+  ## method print {}
+  ## es SÓLO válido cuando `print` no es una `multi` con el mismo dispacho.
+  ## (esto significa que una clase padre puede opacar una `multi print() {}`
+  ## 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. 
+}
+```
+
+## Excepciones
+
+```perl6
+## Excepciones están construidas al tope de las clases, en el paquete 
+## `X` (como `X::IO`).
+## En Perl 6, 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.
+
+## Puedes lanzar una excepción usando `die`:
+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
+## coincide con variables indefinidas, en cambio de cualquier cosa
+## que evalúa a falso.
+## 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 
+## fallo en $_
+## Esto evitará que sea automáticamente manejado e imprima una marejada de
+## mensajes de errores en la pantalla.
+## Podemos usar el método de excepción en $_ para acceder la excepción:
+open 'foo' orelse say "Algo pasó {.exception}";
+
+## Esto también funciona:
+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 
+## obtendremos una advertencia. Más abajo vemos como usar `try` y `CATCH`
+## para ser más expecíficos con las excepciones que capturamos.
+```
+
+### 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 
+## a la variable especial `$!`.
+## Nota: Esto no tiene ninguna relación con las variables $!.
+
+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`
+## *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 
+## cualquier excepción (`CATCH { default {} }`).
+
+try { my $a = (0 %% 0);  CATCH { say "Algo pasó: $_" } }
+ #=> Algo pasó: Attempt to divide by zero using infix:<%%>
+
+## Puedes redefinir lo anterior usando `when` y (`default`)
+## para manejar las excepciones que desees:
+try {
+  open 'foo';
+  CATCH {     # En el bloque `CATCH`, la excepción es asignada a $_
+    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 
+	## tenemos un `default`.
+	## 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`.
+    ## You still can re-throw the exception (see below) by hand.
+  }
+}
+
+## En Perl 6, excepciones poseen ciertas sutilezas. Algunas 
+## subrutinas en Perl 6 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 
+## 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 
+## `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.
+try {
+  fail "foo";
+  CATCH {
+    default { say "Levantó un error porque intentamos acceder el valor del fallo!" }
+  }
+}
+
+## 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). 
+```
+
+## Paquetes
+
+```perl6
+## 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 
+## denominador)
+## 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 
+## la palabra clave `package`. En vez, usa `class Nombre::Paquete::Aquí;`
+## para declarar una clase, o si solamente quieres exportar 
+## variables/subrutinas, puedes usar `module`.
+
+module Hello::World { # forma de llaves
+                      # Si `Hello` no existe todavía, solamente será una cola ("stub"),
+                      #  que puede ser redeclarada más tarde.
+  # ... declaraciones aquí ...
+}
+unit module Parse::Text; # forma de ámbito de archivo
+
+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 
+## 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;
+
+## Veremos como exportar variables y subrutinas en la siguiente parte:
+```
+
+## Declaradores
+
+```perl6
+## En Perl 6, 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 
+## `our` por defecto)
+module Var::Incrementar {
+  our $nuestra-var = 1; # Nota: No puedes colocar una restricción de tipo
+  my $mi-var = 22;      # como Int (por ejemplo) en una variable `our`.
+  our sub Inc {
+
+    our sub disponible { # Si tratas de hacer subrutinas internas `our`...
+                        # Mejor que sepas lo que haces (No lo haga!).
+      say "No hagas eso. En serio. Estás jugando con fuego y te quemarás.";
+    }
+
+    my sub no-disponible { # `my sub` es por defecto
+      say "No puedes acceder aquí desde fuera. Soy 'my'!";
+    }
+    say ++$nuestra-var; # Incrementa la variable paquete y muestra su valor
+  }
+
+}
+say $Var::Incrementar::nuestra-var; #=> 1 Esto funciona
+say $Var::Incrementar::mi-var; #=> (Any) Esto no funcionará.
+
+Var::Incrementar::Inc; #=> 2
+Var::Incrementar::Inc; #=> 3 # Nota como el valor de $nuestra-var fue
+                            # retenido
+Var::Incrementar::no-disponible; #=> Could not find symbol '&no-disponible'
+
+## * `constant` (ocurre al tiempo `BEGIN`)
+## Puedes usar la palabra clave `constant` para declarar una 
+## variable/símbolo al tiempo de compilación:
+constant Pi = 3.14;
+constant $var = 1;
+
+## Y por si te estás preguntando, sí, también puede contener listas infinitas.
+constant porque-no = 5, 15 ... *;
+say porque-no[^5]; #=> 5 15 25 35 45
+
+## * `state` (ocurre al tiempo de ejecución, pero una sola vez)
+## Variables "states" son solo inicializadas una vez.
+## (ellas existen en otros lenguaje como `static` en C)
+sub aleatorio-fijo {
+  state $valor = rand;
+  say $valor;
+}
+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 
+## variable por cada iteración del bucle. Observa:
+for ^5 -> $a {
+  sub foo {
+    state $valor = rand; # Esto imprimirá un valor diferente 
+                         # por cada valor de `$a`
+  }
+  for ^5 -> $b {
+    say foo; # Esto imprimirá el mismo valor 5 veces, pero sólo 5.
+             # La siguiente iteración ejecutará `rand` nuevamente.
+  }
+}
+```
+
+## 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 
+## 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!)
+## Algunos de ellos pueden ser utilizados por sus valores devueltos, otros
+## no pueden (aquellos que tiene un "[*]" al inicio de su texto de
+## explicación).
+## ¡Tomemos una mirada!
+
+## * Phasers al tiempo de compilación
+BEGIN { say "[*] Se ejecuta al tiempo de compilación, " ~
+		    "tan pronto como sea posible, una sola vez" }
+CHECK { say "[*] Se ejecuta al tiempo de compilación, " ~
+			"tan tarde como sea posible, una sola vez" }
+
+## * Phasers al tiempo de ejecución
+INIT { say "[*] Se ejecuta al tiempo de ejecución, " ~
+		   "tan pronto como sea posible, una sola vez" }
+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, " ~ 
+		"se repite en bloques de bucle" }
+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, " ~ 
+        "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.";
+}
+
+## Ejemplos:
+for 0..2 {
+    PRE { $_ > 1 } # Esto fallará con un "Precondition failed"
+}
+
+POST {
+    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.";
+}
+for 0..2 {
+    POST { $_ < 2 } # Esto fallará con un "Postcondition failed"
+}
+
+## * Phasers de bloques/excepciones
+sub {
+    KEEP { say "Se ejecuta cuando sales de un bloque exitosamente
+                (sin lanzar un excepción)" }
+    UNDO { say "Se ejecuta cuando sale de bloque sin éxito
+                (al lanzar una excepción)" }
+}
+
+## * Phasers de bucle
+for ^5 {
+  FIRST { say "[*] La primera vez que un bucle se ejecuta, antes que ENTER" }
+  NEXT { say "Al tiempo de la continuación del bucle, antes que LEAVE" }
+  LAST { say "Al tiempo de la terminación del bucle, después de LEAVE" }
+}
+
+## * Phasers de rol/clase
+COMPOSE { "Cuando un rol es compuesto en una clase. /!\ NO IMPLEMENTADO TODAVÍA" }
+
+## Ellos permite pequeños trucos o código brillante...:
+say "Este código tomó " ~ (time - CHECK time) ~ "s para compilar";
+
+## ... o brillante organización:
+sub do-db-stuff {
+  $db.start-transaction; # comienza una transacción nueva
+  KEEP $db.commit; # commit (procede con) la transacción si todo estuvo bien
+  UNDO $db.rollback; # o retrocede si todo falló
+}
+```
+
+## Prefijos de sentencias
+
+```perl6
+## 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 
+## término.
+## Normalmente no puedes usar una sentencia como un valor (o término):
+##
+##    my $valor = if True { 1 } # `if` es una sentencia - error del parseador
+##
+## Esto funciona:
+my $a = do if True { 5 } # con `do`, `if` ahora se comporta como un término.
+
+## - `once` - se asegura que una porción de código se ejecute una sola vez.
+for ^5 { once say 1 }; #=> 1
+                       # solo imprime ... una sola vez.
+## Al igual que `state`, ellos son clonados por ámbito
+for ^5 { sub { once say 1 }() } #=> 1 1 1 1 1
+                                # Imprime una sola vez por ámbito léxico
+
+## - `gather` - Hilo de co-rutina
+## `gather` te permite tomar (`take`) varios valores en un array,
+##  al igual que `do`. Encima de esto, te permite tomar cualquier expresión.
+say gather for ^5 {
+  take $_ * 3 - 1;
+  take $_ * 3 + 1;
+} #=> -1 1 2 4 5 7 8 10 11 13
+say join ',', gather if False {
+  take 1;
+  take 2;
+  take 3;
+} # no imprime nada.
+
+## - `eager` - Evalúa una sentencia ávidamente (forza contexto ávido)
+## No intentes esto en casa:
+##
+##    eager 1..*; # esto probablemente se colgará por un momento 
+##                # (y podría fallar...).
+##
+## Pero considera lo siguiente:
+constant tres-veces = gather for ^3 { say take $_ }; # No imprime nada
+
+## frente a esto:
+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`. 
+## `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 
+## (forza contexto perezoso)
+my @lazy-array = (1..100).lazy;
+say @lazy-array.is-lazy; #=> True # Chequea por "pereza" con el método `is-lazy`.
+say @lazy-array; #=> [...] No se ha iterado sobre la lista
+for @lazy-array { .print }; # Esto funciona y hará tanto trabajo como sea necesario.
+
+[//]: # ( TODO explica que gather/take y map son todos perezosos)
+## - `sink` - Un `eager` que desecha los resultados (forza el contexto sink)
+constant nilthingie = sink for ^3 { .say } #=> 0 1 2
+say nilthingie.perl; #=> Nil
+
+## - `quietly` - Un bloque `quietly` reprime las advertencias:
+quietly { warn 'Esto es una advertencia!' }; #=> No salida
+
+## - `contend` - Intenta efectos secundarios debajo de STM
+## ¡No implementado todavía!
+```
+
+## ¡Más operadores!
+
+```perl6
+## ¡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
+## Pero primero, necesitamos un poco de explicación acerca
+## de la asociatividad:
+
+## * Operadores binarios:
+$a ! $b ! $c; # con asociatividad izquierda `!`, esto es `($a ! $b) ! $c`
+$a ! $b ! $c; # con asociatividad derecha `!`, esto es `$a ! ($b ! $c)`
+$a ! $b ! $c; # sin asociatividad `!`, esto es ilegal
+$a ! $b ! $c; # con una cadena de asociatividad `!`, esto es `($a ! $b) and ($b ! $c)`
+$a ! $b ! $c; # con asociatividad de lista `!`, esto es `infix:<>`
+
+## * Operadores unarios:
+!$a! # con asociatividad izquierda `!`, esto es `(!$a)!`
+!$a! # con asociatividad derecha `!`, esto es `!($a!)`
+!$a! # sin asociatividad `!`, esto es ilegal
+```
+
+### ¡Crea tus propios operadores!
+
+```perl6
+## 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.
+
+## Puedes declarar un operador como declaras una subrutina:
+sub prefix:<ganar>($ganador) { # se refiere a las categorías de los operadores
+                               # (exacto, es el "operador de palabras" `<>`)
+  say "¡$ganador ganó!";
+}
+ganar "El Rey"; #=> ¡El Rey Ganó!
+                # (prefijo se pone delante)
+
+## todavías puedes invocar la subrutina con su "nombre completo":
+say prefix:<!>(True); #=> False
+
+sub postfix:<!>(Int $n) {
+  [*] 2..$n; # usando el meta-operador reduce ... Ve más abajo!
+}
+say 5!; #=> 120
+        # Operadores sufijos (postfix) van *directamente* después del témino.
+        # 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 
+		  # refiriendo a la variable (no a la función), como con `&r`.
+  }
+}
+3 veces -> { say "hola" }; #=> hola
+                            #=> hola
+                            #=> hola
+                            # Se te recomienda que ponga espacios
+                            # alrededor de la invocación de operador infijo.
+
+## Para los circunfijos y pos-circunfijos
+sub circumfix:<[ ]>(Int $n) {
+  $n ** $n
+}
+say [5]; #=> 3125
+         # un circunfijo va alrededor. De nuevo, no espacios en blanco.
+
+sub postcircumfix:<{ }>(Str $s, Int $idx) {
+  ## 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.
+## 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 
+										  # operadores de esta forma)
+## ¡*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 
+## 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 
+## 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*.
+## Básicamente, ellos son operadores que se aplican a otros operadores.
+
+## * 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 
+## (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 
+## 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 `+`, 
+## i.e.:
+say [+] 1, 2, 3; #=> 6
+## es equivalente a `(1+2)+3`
+
+say [*] 1..5; #=> 120
+## es equivalente a `((((1*2)*3)*4)*5)`.
+
+## Puedes reducir con cualquier operador, no solo con operadores matemáticos.
+## Por ejemplo, podrías reducir con `//` para conseguir
+## el primer elemento definido de una lista:
+say [//] Nil, Any, False, 1, 5; #=> False
+                                # (Falsey, pero definido)
+
+## Ejemplos con valores por defecto:
+say [*] (); #=> 1
+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 
+## 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 
+## 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 
+## 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 
+                 # crea un array.
+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
+(True, False) Z|| (False, False) Z|| (False, False); # (True, False)
+
+## Y pasa que también puedes usarlo con el meta-operador reduce:
+[Z||] (True, False), (False, False), (False, False); # (True, False)
+
+
+## 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 
+## 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, 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
+                               # (con la Whatever Star, aquí).
+my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalente a lo de arriba)
+
+my @fib = 1, 1, *+* ... *; # lista infinita perezosa de la serie fibonacci,
+                           #  computada usando una clausura!
+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), 
+## etc.
+
+say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
+               # (usandi un rango como el índice)
+## Nota: Los elementos de un rango, una vez cosificados, no son re-calculados.
+## Esta es la razón por la cual `@primes[^100]` tomará más tiempo la primera
+## vez que se imprime. Después de esto, será hará en un instante.
+```
+
+## 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) 
+## (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 
+## 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
+## 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 
+## mucho más.
+## 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")
+## ("Parseado de Expresiones de Gramáticas") nativamente. El orden jerárquico
+## 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` 
+## 	  (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
+##     (las gramáticas son actualmente clases)
+##  - La declaración más temprana gana
+say so 'a' ~~ /a/; #=> True
+say so 'a' ~~ / a /; #=> True #  ¡Más legible con los espacios!
+
+## 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 
+## 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 
+## texto aparece ese patrón de caracteres (una `c`, seguida de una `e`,
+## (seguida de una `n`, etc.) 
+
+## 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 
+## texto coincidente.
+## 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, 
+## 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,
+## 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`. Otra forma de escaparlo
+
+## 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
+## 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 
+## dos espacios entre las cadenas de texto o usa el adverbio `:s`.
+
+## 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`
+## Al usar `m` para especificar 'match', podemos también otros delimitadore:
+say so 'abc' ~~ m{a  b  c}; #=> `True`
+say so 'abc' ~~ m[a  b  c]; #=> `True`
+
+## Usa el adverbio :i para especificar que no debería haber distinción entre
+## minúsculas y mayúsculas:
+say so 'ABC' ~~ m:i{a  b  c}; #=> `True`
+
+## Sin embargo, es importante para como los modificadores son aplicados 
+## (lo cual verás más abajo)...
+
+## Cuantificando - `?`, `+`, `*` y `**`.
+## - `?` - 0 o 1
+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 
+## 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
+so 'def' ~~ / 'abc'? /; # `True`. El grupo "abc"completo es opcional.
+
+## Aquí (y más abajo) el cuantificador aplica solamente a la `b`
+
+## - `+` - 1 o más
+so 'ac' ~~ / a  b+  c /; # `False`; `+` quiere por lo menos una coincidencia
+so 'abc' ~~ / a  b+  c /; # `True`; una es suficiente
+so 'abbbbc' ~~ / a  b+  c /; # `True`, coincidió con 4 "b"s
+
+## - `*` - 0 o más
+so 'ac' ~~ / a  b*  c /; # `True`, todos son opcionales.
+so 'abc' ~~ / a  b*  c /; # `True`
+so 'abbbbc' ~~ / a  b*  c /; # `True`
+so 'aec' ~~ / a  b*  c /; # `False`. "b"(s) son opcionales, no reemplazables.
+
+## - `**` - Cuantificador (sin límites)
+## Si entrecierras los ojos lo suficiente, pueder ser que entiendas
+## por qué la exponenciación es usada para la cantidad.
+so 'abc' ~~ / a  b**1  c /; # `True` (exactamente una vez)
+so 'abc' ~~ / a  b**1..3  c /; # `True` (entre una y tres veces)
+so 'abbbc' ~~ / a  b**1..3  c /; # `True`
+so 'abbbbbbc' ~~ / a  b**1..3  c /; # `False` (demasiado)
+so 'abbbbbbc' ~~ / a  b**3..*  c /; # `True` (rangos infinitos no son un problema)
+
+## - `<[]>` - Clases de carácteres
+## Las clases de carácteres son equivalentes a las clases `[]` de PCRE,
+## pero usan una sintaxis de Perl 6:
+say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa'
+
+## Puedes usar rangos:
+say 'aeiou' ~~ / a <[ e..w ]> /; #=> 'ae'
+
+## Al igual que regexes normales, si quieres usar un carácter especial,
+## escápalo (el último está escapando un espacio)
+say 'he-he !' ~~ / 'he-' <[ a..z \! \  ]> + /; #=> 'he-he !'
+
+## Obtendrás una advertencia si pones nombres duplicados
+## (lo cual tiene el efecto de capturar la frase escrita)
+'he he' ~~ / <[ h e ' ' ]> /; # Advierte "Repeated characters found in characters
+                              # class"
+
+## También puedes negarlos... (equivalenta a `[^]` en PCRE)
+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 
+                                          # parte de la izquierda)
+```
+
+### Grupos y Capturas
+
+```perl6
+## Grupo: Puedes agrupar partes de tu regexp con `[]`.
+## 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`.
+## Coincidimos (o encotramos el patrón) "012" una o más de una vez (
+## (el signo `+` fue aplicado al grupo).
+## 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, 
+## 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, 
+### nuestra objeto `Match` está disponible en la variable `$/`:
+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｣
+           # Estos corchetes extranos son los objetos `Match`.
+           # 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 
+## 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 
+## *sea* significante, podemos utilizar el modificador `:sigspace`.
+so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; # `True`
+say $/[0]; #=> ｢ABC｣
+say $0.WHAT; #=> (Match)
+             # Puede haber más de uno, por lo tanto es solo un solo objeto match.
+so 'foobar' ~~ / foo ( "A" "B" "C" )? bar /; #=> True
+say $0.WHAT; #=> (Any)
+             # Esta captura no coincidió, por lo tanto está vacía
+so 'foobar' ~~ / foo ( "A" "B" "C" ) ** 0..1 bar /; # `True`
+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]`, 
+## 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]` 
+## 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" 
+					 # (chequea las acciones más abajo), etc.
+					 # Verás capturas nombradas más abajo con las gramáticas.
+
+## Alternativas - el `or` de regexes
+## Advertencia: Es diferente a los regexes de PCRE.
+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 
+## "Coincidencia de Token Más Larga". Esto significa que el motor ("engine")
+## 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
+## dos partes:
+## El "prefijo declarativo" (la parte que puede ser analizada estáticamente)
+## y las partes procedimentales.
+## Los prefijos declarativos incluyen alternaciones (`|`), conjunciones (`&`),
+## invocaciones de sub-reglas (no han sido introducidos todavía), clases de
+## caracteres y cuantificadores.
+## Las partes procidimentales incluyen todo lo demás: referencias a elementos
+## 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 
+## 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) 
+## 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 
+## deletrea `||`
+'foo' ~~ / fo || foo /; # `fo` ahora.
+```
+
+## 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 
+## nombrados (`--foo`) y hasta autogenerará un `--help`.
+sub MAIN($nombre) { say "¡Hola, $nombre!" }
+## Esto produce:
+##    $ perl6 cli.pl
+##    Uso:
+##      t.pl <nombre>
+
+## Y dado que una subrutina regular en Perl 6, puedes tener múltiples 
+## despachos:
+## (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
+
+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
+##    Uso:
+##      t.pl [--replace] add <key> <value>
+##      t.pl remove <key>
+##      t.pl [--as=<Str>] import (File)
+## Como puedes ver, esto es *realmente* poderoso.
+## Fue tan lejos como para mostrar las constantes en líneas.
+## (el tipo solo se muestra cuando el argumento `$`/ es nombrado)
+```
+
+## APÉNDICE A:
+### Lista de cosas
+
+```perl6
+## Consideramos que por ahora ya sabes lo básico de Perl 6.
+## Esta sección es solo para listar algunas operaciones comunes
+## las cuales no están en la "parte principal" del tutorial.
+
+## Operadores
+
+## * Comparación para ordenar
+## Ellos returnan un valor de los enum `Order`:  `Less`, `Same` y `More`
+##  (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 
+
+## * Ordenación genérica
+3 before 4; # True
+'b' after 'a'; # True
+
+## * Operador (por defecto) de circuito corto 
+## Al igual que `or` y `||`, pero devuelve el primer valor *defined*
+## (definido):
+say Any // Nil // 0 // 5; #=> 0
+
+## * Circuito corto exclusivo or (XOR)
+## Devuelve `True` si uno (y solo uno) de sus argumentos es verdadero:
+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 
+## son `True` hasta que su lado derecho devuelve `True`.
+## 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> {
+  # por defecto, `ff`/`fff` hace coincidencia inteligente (`~~`) contra `$_`:
+  if 'met' ^ff 'meet' { # no entrará el bucle if por "met"
+                        # (se explica más abajo).
+    .say
+  }
+
+  if rand == 0 ff rand == 1 { # compara variables más que `$_`
+    say "Esto ... probablemente nunca se ejecutará ...";
+  }
+}
+## 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`), 
+## 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 
+## 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 
+## 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` 
+                                    # 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ó 
+                                     # inmediamente).
+
+## Un flip-flop puede cambiar estado cuantas veces se necesite:
+for <test start print it stop not printing start print again stop not anymore> {
+  .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # excluye a "start" y "stop",
+                                           #=> "print it print again"
+}
+
+## También podrías usar una Whatever Star, lo cual es equivalente
+## a `True` para el lado izquierdo o `False` para el lado derecho:
+for (1, 3, 60, 3, 40, 60) { # Nota: los paréntesis son superfluos aquí
+                            # (algunas veces se les llaman "paréntesis superticiosos")
+ .say if $_ > 50 ff *; # Una vez el flip-flop alcanza un número mayor que 50,
+                       # no returnará jamás a `False`
+                       #=> 60 3 40 60
+}
+
+## También puedes usar esta propiedad para crear un `If`
+## 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 
+                   # primera iteración
+                   #=> b c
+}
+
+## - `===` es la identidad de valor y usa `.WHICH` 
+## en los objetos para compararlos.
+## - `=:=` 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
+ 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
+ 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).
+ Estos explican P6 desde la perspectiva de un implementador, lo cual es bastante
+ interesante.