Reflect perl6 to raku rename

+ As mentioned here: https://github.com/Raku/problem-solving/blob/master/solutions/language/Path-to-Raku.md perl6 is renamed to raku + change references of perl6 to raku + change extension from .p6 to .raku + fix the link of raku advent calendar
2024-12-23 09:41:36 +00:00 · 2020-06-15 20:42:57 +05:45 · 2020-06-15 20:42:57 +05:45 · d78605e0d7
commit d78605e0d7
parent 0ecb826429
3 changed files with 70 additions and 70 deletions
--- a/es-es/perl6-es.html.markdown
+++ b/es-es/perl6-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,
@ -34,9 +34,9 @@ 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
@ -55,7 +55,7 @@ my $str2 = "Cadena";
 ## (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
@ -105,7 +105,7 @@ my %hash = foo => "bar", 			 # las llaves reciben sus comillas
           ;

 ## 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))
 ```

@ -190,7 +190,7 @@ 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:
@ -256,7 +256,7 @@ concat3(|@array); #=> a, b, c
 ## Contenedores

 ```perl6
-## En Perl 6, valores son actualmente almacenados en "contenedores".
+## 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
@ -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
 ```
@ -339,7 +339,7 @@ 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
 ## lugar donde exista una variable `$_`.
@ -413,7 +413,7 @@ for @array {
 }

 ## La sintaxis de "bloque puntiagudo" no es específica al bucle for.
-## Es solo una manera de expresar un bloque en Perl 6.
+## 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).

@ -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.

@ -555,7 +555,7 @@ $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.
+## Como dijimos anteriormente, Raku tiene subrutinas realmente poderosas.
 ## Veremos unos conceptos claves que la hacen mejores que en cualquier otro
 ## lenguaje :-).
 ```
@ -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`:

@ -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.
@ -779,12 +779,12 @@ outer()(); #=> 'Foo Bar'
 ## Twigils

 ```perl6
-## Hay muchos `twigils` especiales (sigilos compuestos) en Perl 6.
+## 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)

@ -830,7 +830,7 @@ di_ambito(); #=> 1 100 Cambiamos el valor de $*ambito_din_2 en invoca_a_di_ambit
 ## 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.raku.org/language/objects.html).
@ -870,7 +870,7 @@ $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,
@ -955,7 +955,7 @@ class Item does PrintableVal {
 ```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.
+## 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,7 +966,7 @@ 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
@ -1003,7 +1003,7 @@ 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.
@ -1032,8 +1032,8 @@ 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
 ## ellas - entonces, son manejadas.
@ -1098,7 +1098,7 @@ 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.

@ -1168,7 +1168,7 @@ for ^5 -> $a {
 ## Phasers

 ```perl6
-## Un phaser en Perl 6 es un bloque que ocurre a determinados puntos de tiempo
+## 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.
@ -1302,7 +1302,7 @@ 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
+## 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
@ -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
@ -1406,7 +1406,7 @@ sub postcircumfix:<{ }>(Str $s, Int $idx) {
 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;
@ -1488,12 +1488,12 @@ say [[&add]] 1, 2, 3; #=> 6

 ## * 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,
+## 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
@ -1520,7 +1520,7 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55

 ```perl6
 ## Estoy seguro que has estado esperando por esta parte. Bien, ahora que
-## sabes algo acerca de Perl 6, podemos comenzar. Primeramente, tendrás
+## sabes algo acerca de Raku, podemos comenzar. Primeramente, tendrás
 ## que olvidarte acerca de "PCRE regexps" (perl-compatible regexps)
 ## (expresiones regulares compatible de perl).
 ##
@ -1529,7 +1529,7 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
 ## 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
@ -1537,7 +1537,7 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
 ## 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
 ## desempate:
@ -1574,7 +1574,7 @@ say so 'a' ~~ / a /; #=> True #  ¡Más legible con los espacios!
 ## 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`. Otra forma de escaparlo
@ -1583,7 +1583,7 @@ say so 'a|b' ~~ / a \| b /;  # `True`. Otra forma de escaparlo
 ## 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
@ -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:
@ -1779,17 +1779,17 @@ 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
+## 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
 ## `--replace` a cambio de `--replace=1`)
@ -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.

@ -1914,22 +1914,22 @@ for <a b c> {
 ```
 Si quieres ir más allá de lo que se muestra aquí, puedes:

- - Leer la [documentación de Perl 6](https://docs.raku.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).
+ 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.
--- a/python.html.markdown
+++ b/python.html.markdown
@ -772,11 +772,11 @@ if __name__ == '__main__':

    # Call the static method
    print(Human.grunt())            # => "*grunt*"
-    
-    # Cannot call static method with instance of object 
+
+    # Cannot call static method with instance of object
    # because i.grunt() will automatically put "self" (the object i) as an argument
    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given
-                                    
+
    # Update the property for this instance
    i.age = 42
    # Get the property
@ -792,7 +792,7 @@ if __name__ == '__main__':
 ####################################################

 # Inheritance allows new child classes to be defined that inherit methods and
-# variables from their parent class. 
+# variables from their parent class.

 # Using the Human class defined above as the base or parent class, we can
 # define a child class, Superhero, which inherits the class variables like
@ -926,7 +926,7 @@ class Batman(Superhero, Bat):
        # So instead we explicitly call __init__ for all ancestors.
        # The use of *args and **kwargs allows for a clean way to pass arguments,
        # with each parent "peeling a layer of the onion".
-        Superhero.__init__(self, 'anonymous', movie=True, 
+        Superhero.__init__(self, 'anonymous', movie=True,
                           superpowers=['Wealthy'], *args, **kwargs)
        Bat.__init__(self, *args, can_fly=False, **kwargs)
        # override the value for the name attribute
@ -941,9 +941,9 @@ if __name__ == '__main__':

    # Get the Method Resolution search Order used by both getattr() and super().
    # This attribute is dynamic and can be updated
-    print(Batman.__mro__)       # => (<class '__main__.Batman'>, 
-                                # => <class 'superhero.Superhero'>, 
-                                # => <class 'human.Human'>, 
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>,
+                                # => <class 'superhero.Superhero'>,
+                                # => <class 'human.Human'>,
                                # => <class 'bat.Bat'>, <class 'object'>)

    # Calls parent method but uses its own class attribute
--- a/raku.html.markdown
+++ b/raku.html.markdown
@ -2392,7 +2392,7 @@ resource on Raku. If you are looking for something, use the search bar.
 This will give you a dropdown menu of all the pages referencing your search
 term (Much better than using Google to find Raku documents!).

- Read the [Raku Advent Calendar](http://perl6advent.wordpress.com/). This
+- Read the [Raku Advent Calendar](https://rakuadventcalendar.wordpress.com/). This
 is a great source of Raku snippets and explanations. If the docs don't
 describe something well enough, you may find more detailed information here.
 This information may be a bit older but there are many great examples and