spaces in code and link spans

9 files changed, 156 insertions, 162 deletions

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 8992d339..08f6f964 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -15,4 +15,4 @@ jobs:
         with:
           ruby-version: '3.2'
       - run: gem install mdl
-      - run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD047
+      - run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD038,MD039,MD047
diff --git a/es-es/raku-es.html.markdown b/es-es/raku-es.html.markdown
index 0c186682..8efa0349 100644
--- a/es-es/raku-es.html.markdown
+++ b/es-es/raku-es.html.markdown
@@ -10,7 +10,6 @@ translators:
     - ["Luis F. Uceta", "https://github.com/uzluisf"]
 lang: es-es
 ---
-
 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.
 
@@ -58,7 +57,7 @@ my $nombre'de-variable_ = 5; # Esto funciona!
 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
+                            # convierte su operador en un Bool
 ```
 
 ### Arrays y Listas
@@ -74,7 +73,7 @@ my @letras = <a b c>;  # array de palabras, delimitado por espacios.
 my @array = 1, 2, 3;
 
 say @array[2]; # Los índices de un array empiezan por el 0 -- Este es
-			   # el tercer elemento.
+               # el tercer elemento.
 
 say "Interpola todos los elementos de un array usando [] : @array[]";
 #=> Interpola todos los elementos de un array usando [] : 1 2 3
@@ -84,7 +83,7 @@ say "Interpola todos los elementos de un array usando [] : @array[]";
 
 my @llaves = 0, 2;
 @array[@llaves] = @letras; # Asignación usando un array que contiene valores
-						   # índices
+                           # índices
 say @array; #=> a 6 b
 ```
 
@@ -99,8 +98,8 @@ say @array; #=> a 6 b
 ## cualquier llave duplicada es deduplicada.
 my %hash = 1 => 2,
            3 => 4;
-my %hash = foo => "bar", 			 # las llaves reciben sus comillas
-                                     # automáticamente.
+my %hash = foo => "bar",            # las llaves reciben sus comillas
+                                    # automáticamente.
            "some other" => "value", # las comas colgantes estań bien.
            ;
 
@@ -151,9 +150,9 @@ say devolver-vacio; # imprime Nil
 
 ## Algunas estructuras de control producen un valor. Por ejemplo if:
 sub devuelva-si {
-	if True {
-		"Truthy";
-	}
+    if True {
+        "Truthy";
+    }
 }
 say devuelva-si; # imprime Truthy
 
@@ -166,7 +165,7 @@ say return-for; # imprime Nil
 ## Una subrutina puede tener argumentos opcionales:
 sub con-opcional($arg?) { # el signo "?" marca el argumento opcional
   say "Podría returnar `(Any)` (valor de Perl parecido al 'null') si no me pasan
-		un argumento, o returnaré mi argumento";
+    un argumento, o returnaré mi argumento";
   $arg;
 }
 con-opcional;    # devuelve Any
@@ -178,9 +177,9 @@ con-opcional(1); # devuelve 1
 sub hola-a($nombre = "Mundo") {
   say "¡Hola, $nombre!";
 }
-hola-a; 		#=> ¡Hola, Mundo!
-hola-a(); 		#=> ¡Hola, Mundo!
-hola-a('Tú'); 	#=> ¡Hola, Tú!
+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*
@@ -204,12 +203,12 @@ 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")
+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) {
@@ -277,7 +276,7 @@ mutar $m; # ¡$n es ahora 43!
 ## por naturaleza:
 
 mutar 42; # Parámetro '$n' esperaba un contenedor mutable,
-		  # pero recibió un valor Int
+          # pero recibió un valor Int
 
 ## Si en cambio quieres una copia, debes usar `is copy`.
 
@@ -287,7 +286,7 @@ my $x = 42;
 sub x-almacena() is rw { $x }
 x-almacena() = 52; # En este caso, los paréntesis son mandatorios
                 # (porque de otra forma, Raku piensa que la función
-				# `x-almacena` es un identificador).
+                # `x-almacena` es un identificador).
 say $x; #=> 52
 ```
 
@@ -347,7 +346,7 @@ say $edad > 18 ?? "Eres un adulto" !! "Eres menor de 18";
 given "foo bar" {
   say $_; #=> foo bar
   when /foo/ { # No te preocupies acerca de la coincidencia inteligente –
-			   # solo ten presente que `when` la usa.
+               # solo ten presente que `when` la usa.
                # Esto es equivalente a `if $_ ~~ /foo/`.
     say "¡Yay!";
   }
@@ -379,9 +378,9 @@ loop {
 
 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.
+                    # 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!";
 }
 
@@ -398,18 +397,18 @@ for @array {
 
   .say; # Esto es también permitido.
         # Una invocación con punto (dot call) sin "tópico" (recibidor) es
-		# enviada a `$_` por defecto.
+        # 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)
+                   # lenguages parecido a C)
   redo if $_ == 4; # Re-hacer la iteración, manteniendo la
-				   # misma variable tópica (`$_`)
+                   # misma variable tópica (`$_`)
   last if $_ == 5; # Salir fuera del bucle (como `break`
-				   # en lenguages parecido a C)
+                   # en lenguages parecido a C)
 }
 
 ## La sintaxis de "bloque puntiagudo" no es específica al bucle for.
@@ -433,7 +432,7 @@ if computación-larga() -> $resultado {
 ## - "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.
+##                                      posterior a otro término.
 ##                     (como `{`-`}` en `%hash{'key'}`)
 
 ## La lista de asociatividad y precedencia se explica más abajo.
@@ -506,8 +505,8 @@ False ~~ True; # True
 ## 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!)
+                 # 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, 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.
@@ -518,7 +517,7 @@ 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á)
+##       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
@@ -716,8 +715,7 @@ multi dilo(Str $s) { # un multi es una subrutina por defecto
 }
 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 ...")
+            # (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
@@ -743,7 +741,7 @@ multi sin_ti-o-contigo {
 ## en muchos lugares.
 ##
 ## - `is`, por ejemplo, es actualmente un `multi sub` llamado
-##	`trait_mod:<is>`.
+## `trait_mod:<is>`.
 ## - `is rw`, es simplemente un despacho a una función con esta signatura:
 ## sub trait_mod:<is>(Routine $r, :$rw!) {}
 ##
@@ -847,7 +845,7 @@ class Clase-Atrib {
 
   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 `$.`.
+    # $.attrib = $param; # Incorrecto: No puedes usar la versión inmutable `$.`.
 
     $.otro-atrib = 5; # Esto funciona porque `$.otro-atrib` es `rw`.
   }
@@ -864,7 +862,7 @@ 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`).
+                            # público es mutable (`rw`).
 ```
 
 ### Herencia de Objeto
@@ -900,7 +898,7 @@ $Richard.hablar; #=> "Hola, mi nombre es Richard"
 
 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.
+                 # 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`
@@ -1022,11 +1020,11 @@ try {
     when X::AdHoc { say "Error: $_" }
      #=>Error: Failed to open file /dir/foo: no such file or directory
 
-	## Cualquier otra excepción será levantada de nuevo, dado que no
-	## tenemos un `default`.
-	## Básicamente, si un `when`
+    ## 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
+    ## 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.
   }
@@ -1084,7 +1082,7 @@ module Hello::World { # forma de llaves
 unit module Parse::Text; # forma de ámbito de archivo
 
 grammar Parse::Text::Grammar { # Una gramática (grammar en inglés) es un paquete,
-							   # en el cual puedes usar `use`
+                               # 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
@@ -1180,19 +1178,19 @@ for ^5 -> $a {
 
 ## * Phasers al tiempo de compilación
 BEGIN { say "[*] Se ejecuta al tiempo de compilación, " ~
-		    "tan pronto como sea posible, una sola vez" }
+            "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" }
+            "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" }
+           "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" }
+            "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"}
 
@@ -1381,8 +1379,8 @@ say 5!; #=> 120
 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`.
+          # 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
@@ -1412,7 +1410,7 @@ say "abc"{1}; #=> b
 %h{$llave}:delete;
 ## es equivalente a:
 postcircumfix:<{ }>(%h, $llave, :delete); # (puedes invocar
-										  # operadores de esta forma)
+                                          # 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
@@ -1542,7 +1540,7 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
 ## 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)
+##     (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)
@@ -1688,7 +1686,7 @@ so 'fooABCABCbar' ~~ / foo ( 'A' <[A..Z]> 'C' ) + bar /; # `True`. (usando `so`
 ## 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ó
+        # "Nil" si nada coincidió
 
 ## Como dijimos anteriormente, un objeto Match tiene indexación de array:
 say $/[0]; #=> ｢ABC｣ ｢ABC｣
@@ -1733,9 +1731,9 @@ say $/[0][0].Str; #=> ~
 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.
+                     # 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.
@@ -1794,7 +1792,7 @@ sub MAIN($nombre) { say "¡Hola, $nombre!" }
 ## (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
+                                 # un archivo existe
 
 multi MAIN('add', $key, $value, Bool :$replace) { ... }
 multi MAIN('remove', $key) { ... }
@@ -1926,8 +1924,7 @@ Si quieres ir más allá de lo que se muestra aquí, puedes:
  explicaciones. Las publicaciones fueron suspendidas al final del 2015 cuando
  el lenguaje fue declarado estable y Raku.c fue lanzado.
  - Unirte a `#raku` en `irc.freenode.net`. Las personas aquí son siempre serviciales.
- - Chequear la [fuente de las funciones y clases de Raku
- ](https://github.com/rakudo/rakudo/tree/master/src/core.c). Rakudo está principalmente
+ - 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).
diff --git a/fr-fr/elixir-fr.html.markdown b/fr-fr/elixir-fr.html.markdown
index 1de75152..b38afda2 100644
--- a/fr-fr/elixir-fr.html.markdown
+++ b/fr-fr/elixir-fr.html.markdown
@@ -11,8 +11,7 @@ filename: learnelixir-fr.ex
 lang: fr-fr
 ---
 Elixir est un langage de programmation fonctionnel moderne reposant sur la machine virtuelle BEAM, qui héberge aussi Erlang.
-Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités. 
-
+Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités.
 
 ```elixir
 # Un commentaire simple sur une seule ligne commence par un dièse.
@@ -30,21 +29,21 @@ Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréab
 ## ---------------------------
 
 # Il y a les nombres
-3    # Integer 
+3    # Integer
 0x1F # Integer
 3.0  # Float
 
-# Les atomes, des littéraux, qui sont des constantes avec comme valeur leur nom. 
+# Les atomes, des littéraux, qui sont des constantes avec comme valeur leur nom.
 # Ils commencent par `:`.
 
 :hello # atom
 
-# Il existe également des n-uplets dont les valeurs sont stockés de manière contiguë 
+# Il existe également des n-uplets dont les valeurs sont stockés de manière contiguë
 # en mémoire.
 
 {1,2,3} # tuple
 
-# Il est possible d'accéder à un element d'un tuple avec la fonction 
+# Il est possible d'accéder à un element d'un tuple avec la fonction
 # `elem`:
 elem({1, 2, 3}, 0) #=> 1
 
@@ -56,10 +55,10 @@ elem({1, 2, 3}, 0) #=> 1
 head #=> 1
 tail #=> [2,3]
 
-# En Elixir, comme en Erlang, le `=` dénote un 'pattern matching' 
+# En Elixir, comme en Erlang, le `=` dénote un 'pattern matching'
 # (Filtrage par motif) et non une affectation.
-# Cela signifie que la partie de gauche (pattern) est comparé (match) à 
-# la partie de droite. 
+# Cela signifie que la partie de gauche (pattern) est comparé (match) à
+# la partie de droite.
 
 
 # Une erreur sera lancée si aucun model (match) est trouvé.
@@ -151,7 +150,7 @@ nil && 20  #=> nil
 1 != 1 #=> false
 1 < 2  #=> true
 
-# `===` et `!==` sont plus stricts en comparant les Integers (entiers) 
+# `===` et `!==` sont plus stricts en comparant les Integers (entiers)
 # et les Floats (nombres à virgules) :
 1 == 1.0  #=> true
 1 === 1.0 #=> false
@@ -177,7 +176,7 @@ else
 end
 
 # Condition avec `unless` (sauf).
-# Il correspond à la négation d'un `if` (si) 
+# Il correspond à la négation d'un `if` (si)
 unless true do
   "Cela ne sera pas vu"
 else
@@ -223,11 +222,11 @@ cond do
   2 * 5 == 12 ->
     "Moi non plus"
   true ->
-    "Mais moi oui (représente un else)" 
+    "Mais moi oui (représente un else)"
 end
 
-# `try/catch` est utilisé pour attraper les valeurs rejetées. 
-# Il supporte aussi un 
+# `try/catch` est utilisé pour attraper les valeurs rejetées.
+# Il supporte aussi un
 # `after` qui est appelé autant si une valeur est jetée ou non.
 try do
   throw(:hello)
@@ -299,8 +298,8 @@ end
 PrivateMath.sum(1, 2)    #=> 3
 # PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
 
-# La déclaration de fonction supporte également les guards (gardes) 
-# et les clauses. 
+# La déclaration de fonction supporte également les guards (gardes)
+# et les clauses.
 # Quand une fonction avec plusieurs clauses est appelée,
 # la première fonction dont la clause est satisfaite par les arguments sera appelée.
 # Exemple: le code `area({:circle, 3})` appelle la deuxième fonction definie plus bas,
@@ -346,7 +345,7 @@ defmodule MyMod do
 end
 
 # L'opérateur pipe (|>) permet de passer la sortie d'une expression
-# en premier paramètre d'une fonction. 
+# en premier paramètre d'une fonction.
 
 Range.new(1,10)
 |> Enum.map(fn x -> x * x end)
@@ -358,7 +357,7 @@ Range.new(1,10)
 ## ---------------------------
 
 # Les Structs sont des extensions des Maps.
-# Apportant en plus les valeurs par defaut, le polymorphisme et 
+# Apportant en plus les valeurs par defaut, le polymorphisme et
 # la vérification à la compilation dans Elixir.
 defmodule Person do
   defstruct name: nil, age: 0, height: 0
@@ -397,26 +396,26 @@ end
 ## ---------------------------
 
 # Elixir se repose sur le modèle d'acteur pour gérer la concurrence.
-# Pour écrire un programme concurrent en Elixir il faut trois 
-# primitives: spawning processes (création), sending messages (envoi) 
+# Pour écrire un programme concurrent en Elixir il faut trois
+# primitives: spawning processes (création), sending messages (envoi)
 # et receiving messages (réception).
 
-# Pour débuter un nouveau processus, il faut utiliser 
+# Pour débuter un nouveau processus, il faut utiliser
 # la fonction `spawn` qui prend en argument une fonction.
 f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
 spawn(f) #=> #PID<0.40.0>
 
-# `spawn` retourn un pid (identifiant de processus), il est possible 
+# `spawn` retourn un pid (identifiant de processus), il est possible
 # d'utiliser ce pid pour envoyer un message au processus.
 # Pour faire parvenir le message il faut utiliser l'opérateur `send`.
-# Pour que cela soit utile il faut être capable de recevoir les 
+# Pour que cela soit utile il faut être capable de recevoir les
 # messages.
 # Cela est possible grâce au mechanisme de `receive`:
 
 # Le bloc `receive do` est utilisé pour écouter les messages et les traiter
 # au moment de la réception. Un bloc `receive do` pourra traiter un seul
 # message reçu.
-# Pour traiter plusieurs messages, une fonction avec un bloc `receive do` 
+# Pour traiter plusieurs messages, une fonction avec un bloc `receive do`
 # doit s'appeler elle-même récursivement.
 
 defmodule Geometry do
@@ -471,7 +470,7 @@ Agent.update(my_agent, fn colors -> ["blue" | colors] end)
 ## Références
 
 * [Guide de debut](http://elixir-lang.org/getting-started/introduction.html) depuis le site [Elixir](http://elixir-lang.org)
-* [Documentation Elixir ](https://elixir-lang.org/docs.html)
+* [Documentation Elixir](https://elixir-lang.org/docs.html)
 * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
 * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
 * ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert
diff --git a/hi-in/amd.html.markdown b/hi-in/amd.html.markdown
index d4f832fe..3604efb5 100644
--- a/hi-in/amd.html.markdown
+++ b/hi-in/amd.html.markdown
@@ -14,10 +14,10 @@ lang: hi-in
 ### मूल अवधारणा
 
 ```javascript
-// बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : ` define` और` require`
+// बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : `define` और `require`
 // और सभी मॉड्यूल परिभाषा और खपत के बारे में है :
 // `define` एक मॉड्यूल को परिभाषित करता है
-// ` require` निर्भरता का एक सेट का आयात करता है और
+// `require` निर्भरता का एक सेट का आयात करता है और
 // पारित कर दिया कॉलबैक में उन्हें सेवन करती है
 
 // एक नया नाम देकर हम मॉड्यूल को परिभाषित करने का उपयोग करके शुरू करते हैं
@@ -29,13 +29,13 @@ define('awesomeAMD', function(){
   };
 // एक मॉड्यूल के कारखाने समारोह की मान है
   // जब प्राप्त होगा क्या अन्य मॉड्यूल या आवश्यकता कॉल
-  // हमारे ` awesomeAMD` मॉड्यूल की आवश्यकता होती है ।
+  // हमारे `awesomeAMD` मॉड्यूल की आवश्यकता होती है ।
   // निर्यात मूल्य कुछ भी हो सकता है, (निर्माता ) काम करता है,
   // वस्तुओं, पुरातन, (जो कि बहुत ज्यादा मदद नहीं करेगा , हालांकि) भी अपरिभाषित ।
   return isAMDAwesome;
 });
 
-// अब, हमारे ` awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं।
+// अब, हमारे `awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं।
 // हमारे परिभाषित करने के लिए एक अतिरिक्त तर्क है कि नोटिस
 अब // मॉड्यूल की निर्भरता :
 define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
@@ -51,8 +51,8 @@ define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
   return tellEveryone;
 });
 
-// हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए ` require` का उपयोग करते हैं
-// हमारे कार्यक्रम बंद किक । ` require` के हस्ताक्षर है :(arrayOfDependencies, callback)`.
+// हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए `require` का उपयोग करते हैं
+// हमारे कार्यक्रम बंद किक । `require` के हस्ताक्षर है :(arrayOfDependencies, callback)`.
 require(['loudmouth'], function(loudmouth){
   loudmouth();
 });
@@ -90,7 +90,7 @@ require(['modules/someClass'], function(SomeClass){
 console.log('So here we are, waiting!'); // this will run first
 ```
 
-परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । ` require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की ` baseUrl` के सापेक्ष ` modules` फ़ोल्डर में माना गया है :
+परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । `require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की `baseUrl` के सापेक्ष `modules` फ़ोल्डर में माना गया है :
 
 * app/
   * main.js
@@ -102,7 +102,7 @@ console.log('So here we are, waiting!'); // this will run first
     * things.js
     * ...
 
-इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना ` someClass` परिभाषित कर सकते हैं :
+इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना `someClass` परिभाषित कर सकते हैं :
 
 ```javascript
 /* file: app/modules/someClass.js */
@@ -116,7 +116,7 @@ define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
 });
 ```
 
-अपने ` main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग ` requirejs.config ( configObj ) ` में परिवर्तन करने के लिए:
+अपने `main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग `requirejs.config ( configObj )` में परिवर्तन करने के लिए:
 
 ```javascript
 /* file: main.js */
@@ -129,13 +129,13 @@ requirejs.config({
   }
 });
 require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
-  //एक ` main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है,
+  //एक `main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है,
   // अन्यथा कोई कोड कभी चलेंगे
   coolLib.doFancyStuffWith(helpers.transform($('#foo')));
 });
 ```
 
-` require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में ` require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु (` main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा :
+`require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में `require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु ( `main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा :
 
 ```html
 <!DOCTYPE html>
@@ -153,7 +153,7 @@ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolL
 
 कई लोगों को विकास के दौरान समझदार कोड संगठन के लिए एएमडी का उपयोग कर पसंद करते हैं, लेकिन अभी भी पेज लोड पर XHRs के सैकड़ों करने के बजाय उत्पादन में एक भी स्क्रिप्ट फ़ाइल जहाज करने के लिए चाहते हैं।
 
-(राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) ` require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि ` r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है।
+(राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) `require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि `r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है।
 Install it using `npm`:
 
 ```shell
@@ -183,33 +183,34 @@ $ r.js -o app.build.js
 })
 ```
 
-उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस ` Data-main` स्वैप:
+उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस `Data-main` स्वैप:
 
 ```html
 <script src="require.js" data-main="app/main-built"></script>
 ```
 
-एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन] (https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है।
+एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन](https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है।
 
 ### विषय इस ट्यूटोरियल में शामिल नहीं
-* [लोडर प्लगइन्स / रूपांतरण] (http://requirejs.org/docs/plugins.html)
-* [CommonJS शैली लोड हो रहा है और निर्यात] (http://requirejs.org/docs/commonjs.html)
-* [उन्नत विन्यास] (http://requirejs.org/docs/api.html#config)
-* [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)] (http://requirejs.org/docs/api.html#config-shim)
-* [सीएसएस लदान और require.js साथ अनुकूलन] (http://requirejs.org/docs/optimization.html#onecss)
-* (Https://github.com/jrburke/almond) [बनाता है के लिए almond.js का प्रयोग]
+
+* [लोडर प्लगइन्स / रूपांतरण](http://requirejs.org/docs/plugins.html)
+* [CommonJS शैली लोड हो रहा है और निर्यात](http://requirejs.org/docs/commonjs.html)
+* [उन्नत विन्यास](http://requirejs.org/docs/api.html#config)
+* [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)](http://requirejs.org/docs/api.html#config-shim)
+* [सीएसएस लदान और require.js साथ अनुकूलन](http://requirejs.org/docs/optimization.html#onecss)
+* [बनाता है के लिए almond.js का प्रयोग](Https://github.com/jrburke/almond)
 
 ### अग्रिम पठन:
 
-* [सरकारी कल्पना] (https://github.com/amdjs/amdjs-api/wiki/AMD)
-* [क्यों एएमडी?] (Http://requirejs.org/docs/whyamd.html)
-* [यूनिवर्सल मॉड्यूल परिभाषा] (https://github.com/umdjs/umd)
+* [सरकारी कल्पना](https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [क्यों एएमडी?](Http://requirejs.org/docs/whyamd.html)
+* [यूनिवर्सल मॉड्यूल परिभाषा](https://github.com/umdjs/umd)
 
 ### कार्यान्वयन:
 
-* [Require.js] (http://requirejs.org)
-* [डोजो टूलकिट] (http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
-* [Cujo.js] (http://cujojs.com/)
-* [Curl.js] (https://github.com/cujojs/curl)
-* [Lsjs] (https://github.com/zazl/lsjs)
-* [एमडी] (https://github.com/alexlawrence/mmd)
+* [Require.js](http://requirejs.org)
+* [डोजो टूलकिट](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [Cujo.js](http://cujojs.com/)
+* [Curl.js](https://github.com/cujojs/curl)
+* [Lsjs](https://github.com/zazl/lsjs)
+* [एमडी](https://github.com/alexlawrence/mmd)
diff --git a/hi-in/d.html.markdown b/hi-in/d.html.markdown
index 534b83b0..8809c87e 100644
--- a/hi-in/d.html.markdown
+++ b/hi-in/d.html.markdown
@@ -18,16 +18,15 @@ void main(string[] args) {
 ```
 
 अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अधिक समय खर्च करते हैं, तो आप बाधाओं के बारे में सुना है
-के बारे में [डी ] ( http://dlang.org/ )। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
+के बारे में [डी](http://dlang.org/)। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
 सब कुछ के लिए समर्थन कम स्तर की सुविधाओं से करने के साथ बहु - प्रतिमान भाषा
 अर्थपूर्ण उच्च स्तरीय चीजें ।
 
 D सक्रिय रूप से सुपर स्मार्ट लोगों का एक बड़ा समूह द्वारा विकसित की है और नेतृत्व द्वारा किया जाता है
-[ वाल्टर ब्राइट ] ( https://en.wikipedia.org/wiki/Walter_Bright ) और
-[ आंद्रेई Alexandrescu ] ( https://en.wikipedia.org/wiki/Andrei_Alexandrescu )।
+[वाल्टर ब्राइट](https://en.wikipedia.org/wiki/Walter_Bright) और
+[आंद्रेई Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu)।
 जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं!
 
-
 ```c
 import std.stdio;
 
@@ -48,9 +47,9 @@ void main() {
     do {
         n -= (n / 2);
     } while(n > 0);
-    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
-    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
-    // लेकिन पिछले छोड़कर।
+    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
+    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
+    // लेकिन पिछले छोड़कर।
     foreach(i; 1..1_000_000) {
         if(n % 2 == 0)
             writeln(i);
@@ -67,7 +66,7 @@ void main() {
 }
 ```
 
-हम ' struct`, `class`,` union`, और `` enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
+हम `struct`, `class`, `union`, और `enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
 मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा,
 हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं!
 
@@ -130,8 +129,8 @@ auto mat = new Matrix!(3, 3);
 
 Classes की बात हो रही है , एक दूसरे के लिए गुणों के बारे में बात करते हैं। एक संपत्ति
 एक value की तरह कार्य कर सकते हैं कि एक समारोह में मोटे तौर पर है, इसलिए हम कर सकते हैं
-के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (` structure.x = 7` ) है
-मनुष्य और सेटर तरीकों ( ` object.setX (7) `) !
+के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (`structure.x = 7`) है
+मनुष्य और सेटर तरीकों (`object.setX(7)`) !
 
 ```c
 // Consider a class parameterized on types 'T' & 'U'.
@@ -197,15 +196,15 @@ void main() {
 सीधे सदस्यों तक पहुँचने !
 
 हमारे निपटान पर अन्य वस्तु उन्मुख उपहार
-` interface`s , ` सार class`es शामिल
-और ` तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
+`interface`s , `सार class`es शामिल
+और `तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
 आप कृपया के रूप में कई इंटरफेस को लागू करने, एक वर्ग का विस्तार ।
 
 हम डी एस OOP सुविधाओं देखा , लेकिन स्विच गियर छोड़ दिया । डी प्रस्तावों
-प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, ` pure`
+प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, `pure`
 काम करता है, और अपरिवर्तनीय डेटा । इसके अलावा, अपने पसंदीदा के सभी
 कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं)
-अद्भुत ` std.algorithm` मॉड्यूल में पाया!
+अद्भुत `std.algorithm` मॉड्यूल में पाया!
 
 ```c
 import std.algorithm : map, filter, reduce;
@@ -229,7 +228,7 @@ void main() {
 यही कारण है कि एक डी नवाचार करने के लिए धन्यवाद वर्दी समारोह कॉल सिंटेक्स के रूप में जानते हैं।
 UFCS के साथ, हम एक विधि के रूप में एक समारोह कॉल लिखने के लिए चुन सकते हैं
 या मुफ्त समारोह कॉल ! वाल्टर इस पर एक अच्छा लेख लिखा था
-[यहाँ ।] ( http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 )
+[यहाँ ।](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
 संक्षेप में, आप जिनकी पहली पैरामीटर कार्यों कॉल कर सकते हैं
 एक विधि के रूप में ग्रुप ए की किसी भी अभिव्यक्ति पर कुछ प्रकार एक की है ।
 
diff --git a/it-it/logtalk-it.html.markdown b/it-it/logtalk-it.html.markdown
index 093eadb9..dfb9cd27 100644
--- a/it-it/logtalk-it.html.markdown
+++ b/it-it/logtalk-it.html.markdown
@@ -45,7 +45,7 @@ Un oggetto incapsula le dichiarazioni e le definizioni dei predicati. Gli oggett
 
 # Compilazione e il caricamento dei file sorgenti
 
-Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file` list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):
+Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file `list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):
 
 ```logtalk
 ?- {list}.
@@ -53,7 +53,7 @@ yes
 ```
 
 In generale, le entità potrebbero avere dipendenze sulle entità definite in altri file di origine (ad esempio le entità di biblioteca). Per caricare un file e tutte le sue dipendenze, la soluzione consigliata consiste nel definire un file _loader_ che carica tutti i file necessari per un'applicazione. Un file loader è semplicemente un file di origine, in genere denominato `loader.lgt`, che effettua chiamate ai predicati built-in `logtalk_load/1-2`, di solito
-da una direttiva `initialization/1` per la portabilità e conformità agli standard. Caricatore file vengono forniti per tutte le librerie, strumenti ed esempi. 
+da una direttiva `initialization/1` per la portabilità e conformità agli standard. Caricatore file vengono forniti per tutte le librerie, strumenti ed esempi.
 
 # Inviare un messaggio ad un oggetto
 
@@ -67,7 +67,7 @@ X = 3
 yes
 ```
 
-Analogamente alla programmazione object-oriented, logtalk consente anche l'Incapsulamento. 
+Analogamente alla programmazione object-oriented, logtalk consente anche l'Incapsulamento.
 Un predicato può essere dichiarata pubblico, protetto o privato. Può anche essere _local_ quando non esiste una direttiva specifica per esso all'interno dello scope. Per esempio:
 
 ```logtalk
@@ -475,7 +475,7 @@ X = 3
 yes
 ```
 
-Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e` abolish_events/5` .
+Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e `abolish_events/5`.
 
 La programmazione event-driven può essere vista come una forma di _computational reflection_. Si noti però che gli eventi sono generati solo quando si utilizza il costrutto di controllo per l'invio di messaggi `::/2`.
 
diff --git a/pt-br/d-pt.html.markdown b/pt-br/d-pt.html.markdown
index cb664643..e01eae77 100644
--- a/pt-br/d-pt.html.markdown
+++ b/pt-br/d-pt.html.markdown
@@ -21,13 +21,13 @@ void main(string[] args) {
 ```
 
 Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido
-sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
+sobre [D](http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
 linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até
 abstrações expressivas de alto nível.
 
 D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por
-[Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e
-[Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+[Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) e
+[Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
 Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos!
 
 ```d
@@ -71,7 +71,7 @@ void main() {
 }
 ```
 
-Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões
+Podemos definir novos tipos com `struct`, `class`, `union` e `enum`. Estruturas e uniões
 são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso,
 podemos usar modelos para parametrizar tudo isso em tipos e valores!
 
@@ -114,7 +114,7 @@ T max(T)(T a, T b) {
     return a;
 }
 
-// Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a' 
+// Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a'
 // e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'.
 void swap(T)(ref T a, ref T b) {
     auto temp = a;
@@ -179,7 +179,7 @@ class MyClass(T, U) {
 void main() {
     auto mc = new MyClass!(int, string)(7, "seven");
 
-    // Importe o módulo 'stdio' da biblioteca padrão para gravar no 
+    // Importe o módulo 'stdio' da biblioteca padrão para gravar no
     // console (as importações podem ser locais para um escopo).
     import std.stdio;
 
@@ -215,7 +215,7 @@ import std.algorithm : map, filter, reduce;
 import std.range : iota; // cria uma gama exclusiva de final
 
 void main() {
-    // Queremos imprimir a soma de uma lista de quadrados de ints pares 
+    // Queremos imprimir a soma de uma lista de quadrados de ints pares
     // de 1 a 100. Fácil!
 
     // Basta passar expressões lambda como parâmetros de modelo!
@@ -232,16 +232,16 @@ Observe como conseguimos construir um bom pipeline haskelliano para calcular num
 Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS).
 Com o UFCS, podemos optar por escrever uma chamada de função como método
 ou chamada de função grátis! Walter escreveu um bom artigo sobre isso
-[aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+[aqui](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394).
 Em resumo, você pode chamar funções cujo primeiro parâmetro
 é de algum tipo A em qualquer expressão do tipo A como método.
 
 Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco!
 
 ```d
-// Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos 
-// os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos 
-// fazer isso simultaneamente, aproveitando o número de núcleos que temos 
+// Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos
+// os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos
+// fazer isso simultaneamente, aproveitando o número de núcleos que temos
 // disponível.
 
 import std.stdio;
@@ -252,7 +252,7 @@ void main() {
     // Crie sua grande variedade
     auto arr = new double[1_000_000];
 
-    // Use um índice, acesse todos os elementos da matriz por referência (porque vamos 
+    // Use um índice, acesse todos os elementos da matriz por referência (porque vamos
     // mudar cada elemento) e apenas chame paralelo na matriz!
     foreach(i, ref elem; parallel(arr)) {
         elem = sqrt(i + 1.0);
diff --git a/ru-ru/php-composer-ru.html.markdown b/ru-ru/php-composer-ru.html.markdown
index 35f9bd00..fb326009 100644
--- a/ru-ru/php-composer-ru.html.markdown
+++ b/ru-ru/php-composer-ru.html.markdown
@@ -27,12 +27,12 @@ curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filena
 ```
 
 Пользователи Windows должны следовать
-[Инструкциям по установке в Windows ](https://getcomposer.org/doc/00-intro.md#installation-windows)
+[Инструкциям по установке в Windows](https://getcomposer.org/doc/00-intro.md#installation-windows)
 
 ## Подтверждение установки
 
 ```sh
-# # Проверить версию и перечислить параметры
+# Проверить версию и перечислить параметры
 composer
 
 # Получить дополнительную помощь для параметров
@@ -56,13 +56,13 @@ Composer сохраняет ваши зависимости проекта в `c
 #  Создать новый проект в текущей папке
 composer init
 # запускается интерактивная анкета с просьбой предоставить подробную информацию о вашем проекте.
-# Вы прекрасно можете оставить ответы пустыми, если не делаете другие проекты 
+# Вы прекрасно можете оставить ответы пустыми, если не делаете другие проекты
 # зависимыми от создаваемого проекта.
 
 # Если файл composer.json уже существует, загрузите зависимости
 composer install
 
-# Чтобы загрузить только зависимости для готового продукта, т.е. 
+# Чтобы загрузить только зависимости для готового продукта, т.е.
 # исключая зависимости для разработки
 composer install --no-dev
 
@@ -99,12 +99,11 @@ composer search mailgun
 [Packagist.org](https://packagist.org/) является основным хранилищем для пакетов Composer.
 Существующие сторонние пакеты ищите там.
 
-## composer.json` и `composer.lock`
+## `composer.json` и `composer.lock`
 
 Файл `composer.json` хранит параметры допустимых версий каждой зависимости
 вашего проекта, а также другую информацию.
 
-
 Файл `composer.lock` хранит точную загруженную версию каждой зависимости.
 Никогда не редактируйте этот файл.
 
@@ -121,7 +120,7 @@ composer update
 # Если вам нужна новая версия определённой зависимости:
 composer update phpunit/phpunit
 
-# Если вы хотите перенести пакет на более новую версию 
+# Если вы хотите перенести пакет на более новую версию
 #с изменением предпочитаемой версии,
 # вам может потребоваться сначала удалить старый пакет и его зависимости.
 composer remove --dev phpunit/phpunit
@@ -141,7 +140,6 @@ $mailgun = new Mailgun\Mailgun("key");
 
 ### PSR-4-совместимый автозагрузчик
 
-
 Вы можете добавить в автозагрузчик свои собственные пространства имён.
 
 Добавьте поле `autoload` в `composer.json`:
@@ -190,7 +188,7 @@ composer clear-cache
 
 * Создание и распространение ваших собственных пакетов на Packagist.org или в другом репозитории
 * Предварительные и пост-скриптовые перехватчики: запуск задач,
-когда происходят определенные события Composer
+ когда происходят определенные события Composer
 
 ### Ссылки
 
diff --git a/tr-tr/css-tr.html.markdown b/tr-tr/css-tr.html.markdown
index d13dadcc..c72636b6 100644
--- a/tr-tr/css-tr.html.markdown
+++ b/tr-tr/css-tr.html.markdown
@@ -134,19 +134,19 @@ selector::after {}
    #################### */
 
 selector {
-	
-	/* Ölçü birimleri kesin veya göreceli olabilir.*/
 
-	/* Göreceli birimler */
+    /* Ölçü birimleri kesin veya göreceli olabilir.*/
+
+    /* Göreceli birimler */
     width: 50%;       /* Ebeveyn elementin yüzdesel olarak genişliği */
     font-size: 2em;   /* Öğenin özgün yazı tipi boyutunda katları */
     font-size: 2rem;  /* veya kök ögenin yazı tipi boyutu */
     font-size: 2vw;   /* Görüntüleme çerçevesinin genişliğinin %1 olarak katları (CSS 3) */
     font-size: 2vh;   /* veya onun yüksekliğinin */
-	font-size: 2vmin; /* Bir vh veya vw'nin hangisi küçükse */
-	font-size: 2vmax; /* veya daha büyük... */
+    font-size: 2vmin; /* Bir vh veya vw'nin hangisi küçükse */
+    font-size: 2vmax; /* veya daha büyük... */
 
-	/* Kesin birimler */
+    /* Kesin birimler */
     width: 200px;     /* Piksel */
     font-size: 20pt;  /* Nokta */
     width: 5cm;       /* Santimetre */
@@ -236,7 +236,7 @@ Stilin önceliği ise aşağıdaki gibidir. Unutmayın, öncelik **her bir özel
 
 * `E` `!important` kelimesi yüzünden en yüksek önceliğe sahiptir. Kullanımından kaçınmanız önerilir.
 * `F` satıriçi stil olduğu için bir sonraki önceliğe sahiptir.
-* `A` bir sonraki önceliğe sahiptir. Çünkü her şeyden daha "özgüdür". 3 belirteci vardır: `p` ögesinin adı, sınıf` class1`, bir öznitelik `attr = 'değer'.
+* `A` bir sonraki önceliğe sahiptir. Çünkü her şeyden daha "özgüdür". 3 belirteci vardır: `p` ögesinin adı, sınıf `class1`, bir öznitelik `attr = 'değer'.
 * `C`, `B` ile aynı özdeşliğe sahip olsa da, bundan sonra geldiğinden dolayı öncelik hakkına sahiptir.
 * `B` bir sonraki önceliğe sahiptir.
 * Sonuncu önceliğe sahip olan`D`'dir.
@@ -271,7 +271,7 @@ h1 {
 ```
 
 Medya sorguları aşağıdaki bu özellikleri içerebilir:
-`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Bu özelliklerin birçoğunu `min-` veya `max-` öneki ile kullanabilirsiniz. 
+`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Bu özelliklerin birçoğunu `min-` veya `max-` öneki ile kullanabilirsiniz.
 
 `resolution` özelliği eski cihazlarda desteklenmediğinden ötürü `device-pixel-ratio` kullanın.